From a7fa05ebd2c588faa1cca0d455d490c80d4e67d2 Mon Sep 17 00:00:00 2001
From: Marc Pound <22331890+mpound@users.noreply.github.com>
Date: Fri, 28 Jul 2023 15:45:33 -0400
Subject: [PATCH 01/12] Update release.yml

---
 .github/workflows/release.yml | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 79225957..f4643ab5 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,10 +1,9 @@
+name: Publish Release to PyPi
+
 on:
   release:
-    types: 
-      - published
-
-name: release
-
+    types: [ published ]
+  workflow_dispatch:
 jobs:
   build:
     runs-on:  ${{ matrix.os }}

From 3dc8df205c569b8e4194d7fb2f75f6ae7633e26a Mon Sep 17 00:00:00 2001
From: Marc Pound <22331890+mpound@users.noreply.github.com>
Date: Fri, 28 Jul 2023 15:48:02 -0400
Subject: [PATCH 02/12] Update build.yml

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1d33e17c..6e6ecc1a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,4 +1,4 @@
-name: hatch build
+name: Build with hatch
 
 on:
   release:

From d64fda57c1452f8a178af15ebb70c82ee6260506 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Wed, 23 Aug 2023 16:23:38 -0400
Subject: [PATCH 03/12] Fix syntax error in release.yaml

---
 .github/workflows/release.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f4643ab5..1eb44e84 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -4,11 +4,12 @@ on:
   release:
     types: [ published ]
   workflow_dispatch:
+
 jobs:
   build:
     runs-on:  ${{ matrix.os }}
     environment: release
-    
+
     strategy:
       fail-fast: false
       matrix:
@@ -26,7 +27,8 @@ jobs:
         pip install -r requirements-dev.txt
         pip install -e .
     - name: Build with hatch
-        hatch build -c 
+      run: |
+        hatch build -c
 
   pypi-publish:
     name: upload release to PyPI

From 993ee64a04887bb02e051488a3eecfbe5aeab467 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 14:20:15 -0400
Subject: [PATCH 04/12] Updates to pre-commit hooks and pyproject config

Hatch:
- Add test envs
- Add [dev] and [docs] optional-dependencies "features"
- Add new scripts for easy linting/testing/doc-building

Linting/tooling:
- Expand ruff linting rule selections
- Replace isort config; replace with ruff
- Remove pyright config

pre-commit:
- No longer using isort; replaced with ruff
- Tweaks to black args
- Update pip-compile step so it works with pyproject.toml (installs all
optional dependencies and dumps them to requirements.txt)
- Run $ pre-commit auto-update
---
 .github/workflows/build.yml          |   4 +-
 .github/workflows/python-package.yml |   6 +-
 .pre-commit-config.yaml              |  30 ++++---
 pyproject.toml                       | 115 ++++++++++++++++-----------
 4 files changed, 96 insertions(+), 59 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6e6ecc1a..44c02b78 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -9,7 +9,7 @@ jobs:
   build:
     runs-on:  ${{ matrix.os }}
     environment: hatch build
-    
+
     strategy:
       fail-fast: false
       matrix:
@@ -28,4 +28,4 @@ jobs:
         pip install -e .
     - name: Build with hatch
       run: |
-        hatch build -c 
+        hatch build -c
diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 81559e3f..92cec89c 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -11,12 +11,12 @@ on:
 jobs:
   build:
     runs-on:  ${{ matrix.os }}
-    
+
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11"]
 
     steps:
     - uses: actions/checkout@v3
@@ -32,4 +32,4 @@ jobs:
         pip install -e .
     - name: Test with pytest
       run: |
-        pytest
\ No newline at end of file
+        pytest
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6f0a6dba..c4ff46f2 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,7 +1,7 @@
 ---
 # See https://pre-commit.com for more information
 default_language_version:
-  python: python3.8
+  python: python3.9
 
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
@@ -12,8 +12,6 @@ repos:
       - id: end-of-file-fixer
         exclude: LICENSE
       - id: check-yaml
-      # Might make sense once everything is at Python 3
-      # - id: check-ast
       - id: check-added-large-files
         args:
           - '--maxkb=1024'
@@ -21,18 +19,32 @@ repos:
       - id: mixed-line-ending
         args:
           - '--fix=lf'
-      - id: check-docstring-first
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.0.285
     hooks:
-      - id: isort
+    - id: ruff
+      alias: autoformat
+      args:
+        - '--fix'
+        - '--exit-non-zero-on-fix'
+        - '--select=F,E,B,I'
+        - '--ignore=E501'
+
   - repo: 'https://github.com/psf/black'
-    rev: 23.1.0
+    rev: 23.7.0
     hooks:
       - id: black
+
+
   - repo: https://github.com/jazzband/pip-tools
-    rev: 6.12.3
+    rev: 7.3.0
     hooks:
       - id: pip-compile
         args:
+          - 'pyproject.toml'
+          - '--all-extras'
           - '--resolver=backtracking'
+          - '--output-file=requirements.txt'
+          - '--no-strip-extras'
+          - '--quiet'
diff --git a/pyproject.toml b/pyproject.toml
index 86e03555..eb0ebbb8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,11 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
 [project]
 name = "dysh"
 description = ''
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = {file = "LICENSE"}
 keywords = []
+dynamic = ["version"]
 authors = [
   { name = "Marc Pound", email = "mpound@umd.edu" },
   { name = "Victoria Catlett", email = "vcatlett@nrao.edu" },
@@ -17,33 +14,46 @@ authors = [
   { name = "Pedro Salas", email = "psalas@nrao.edu" },
 ]
 classifiers = [
-  "Development Status :: 1 - Planning",
+  "Development Status :: 3 - Alpha",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: Implementation :: CPython",
 ]
-dependencies = ["astropy",
-                "matplotlib",
-                "numpy",
-                "pandas",
-                "scipy",
-                "specutils",
-                "sphinx",
-                "myst-parser"
-               ]
+dependencies = [
+  "astropy",
+  "matplotlib",
+  "numpy",
+  "pandas",
+  "scipy",
+  "specutils",
+  "sphinx",
+  "myst-parser"
+ ]
 
-dynamic = ["version"]
+[project.optional-dependencies]
+dev = [
+  "ipdb",
+  "ipython",
+  "pytest",
+  "pytest-cov",
+  "wget",
+]
+docs = [
+  "myst-parser",
+  "sphinx",
+  "sphinx-autobuild",
+  "sphinx-rtd-theme",
+  "sphinxcontrib-mermaid",
+  "numpydoc"
+]
 
 [project.urls]
 Documentation = "https://github.com/GreenBankObservatory/dysh#readme"
 Issues = "https://github.com/GreenBankObservatory/dysh/issues"
 Source = "https://github.com/GreenBankObservatory/dysh"
 
-#[project.scripts]
-#dysh = "dysh.dysh:main"
 [project.scripts]
 fdr = "dysh.util.files:main_cli"
 
@@ -51,23 +61,28 @@ fdr = "dysh.util.files:main_cli"
 path = "src/dysh/__init__.py"
 
 [tool.hatch.envs.default]
-dependencies = [
-  "pytest",
-  "pytest-cov",
-]
+# By default hatch will effectively do $ pip install dysh[dev]
+features = ["dev"]
 
+# run via: $ hatch run <script>
 [tool.hatch.envs.default.scripts]
+test = "pytest {args}"
+lint = "ruff check . {args}"
+lint-all = "ruff check --select ALL {args}"
+lint-fix = "ruff check --select ALL --fix {args}"
+docs = "sphinx-autobuild {root}/docs {root}/docs/build -b html {args}"
+docs-build = "sphinx-build {root}/docs {root}/docs/build -b html {args}"
+
+[tool.hatch.envs.test]
+
+# run via: $ hatch run test:<script>
+[tool.hatch.envs.test.scripts]
+run = "pytest {args}"
 cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/dysh --cov=tests {args}"
-no-cov = "cov --no-cov {args}"
-
-[tool.hatch.envs.docs]
-dependencies = [
-  "sphinx",
-  "myst-parser"
-]
 
+# Run tests across all supported version of Python
 [[tool.hatch.envs.test.matrix]]
-python = ["38", "39", "310", "311"]
+python = ["39", "310", "311"]
 
 [tool.hatch.build.targets.sdist]
 include = ["/src", "/tests", "/bin"]
@@ -105,23 +120,33 @@ preview = true
 line-length = 120
 
 [tool.ruff]
+select = [
+  "F",    # https://beta.ruff.rs/docs/rules/#pyflakes-f
+  "E",    # https://beta.ruff.rs/docs/rules/#error-e
+  "W",    # https://beta.ruff.rs/docs/rules/#warning-w
+  "B",    # https://beta.ruff.rs/docs/rules/#flake8-bugbear-b
+  "I",    # https://beta.ruff.rs/docs/rules/#isort-i
+  "NPY",  # https://beta.ruff.rs/docs/rules/#numpy-specific-rules-npy
+  "PD",   # https://beta.ruff.rs/docs/rules/#pandas-vet-pd
+  "RUF",  # https://beta.ruff.rs/docs/rules/#ruff-specific-rules-ruf
+]
+fixable = ["ALL"]
+unfixable = ["B"]
+ignore = [
+  "E501",  # Ignore line length violations
+]
 line-length = 120
 
-[tool.pyright]
-reportImplicitStringConcatenation = false
-
-[tool.isort]
-# See: https://pycqa.github.io/isort/docs/configuration/options/#example-pyprojecttoml
-profile = "black"
-combine_as_imports = true
-sections = [
-    "FUTURE",
-    "STDLIB",
-    "THIRDPARTY",
-    "FIRSTPARTY",
-    "LOCALFOLDER"
-]
+# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["E402"]
+"path/to/file.py" = ["E402"]
+"**/{tests,docs,tools}/*" = ["E402", "B011"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"
 testpaths = ["tests", "src", "docs"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

From bf3c6a0a6a172d77a8ba63ab3c6e6bfecb639824 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 14:40:08 -0400
Subject: [PATCH 05/12] Run all pre-commit hooks

Note: there are currently 27 linting errors from ruff. I am leaving
these in here; they will need to be either fixed, or skipped using '$ SKIP=ruff git commit
...' before further commits can be made
---
 README.md                                    |   7 +-
 attic/sdfitsload.py                          | 463 +++++++-------
 attic/test_s1d.py                            |  73 ++-
 benchmark/README.md                          |  15 +-
 benchmark/benchmark_py.csh                   |   2 +-
 benchmark/makeplots.py                       | 304 +++++----
 benchmark/revisedstructure.py                | 155 ++---
 benchmark/stats-wcs-meta.2022-03-31-OMP=1    |   2 -
 benchmark/stats-wcs-meta.2022-04-02-OMPunset |   2 -
 benchmark/tab.out                            |   5 +-
 benchmark/tab_gbtidl.out                     |   4 +-
 benchmark/tab_newton.out                     |  10 +-
 benchmark/tab_newton_linearlsq.out           |  12 +-
 benchmark/tab_omp=1.out                      |  18 +-
 benchmark/tab_omp_unset.out                  |  18 +-
 configure                                    |   2 -
 configure.ac                                 |   2 +-
 docs/conf.py                                 |  44 +-
 docs/index.rst                               |  10 +-
 docs/install.rst                             |  11 +-
 docs/install_developer.md                    |  20 +-
 docs/performance.rst                         |   1 -
 docs/positionswitch.rst                      |  17 +-
 docs/subbeamnod.rst                          |   9 +-
 docs/totalpower.rst                          |   6 +-
 dysh_start.sh.in                             |   1 -
 notebooks/developer/README.md                |   2 -
 requirements.txt                             | 303 ++++++++-
 requirements_dev.txt                         |   2 +-
 src/dysh/__init__.py                         |   1 +
 src/dysh/_dysh_init.py                       |   1 -
 src/dysh/fits/__init__.py                    |   2 +-
 src/dysh/fits/gbtfitsload.py                 | 634 ++++++++++---------
 src/dysh/fits/sdfitsload.py                  | 525 ++++++++-------
 src/dysh/fits/tests/test_gbtfitsload.py      |  59 +-
 src/dysh/plot/__init__.py                    |   2 +-
 src/dysh/plot/specplot.py                    | 182 +++---
 src/dysh/spectra/__init__.py                 |   2 +-
 src/dysh/spectra/core.py                     | 407 ++++++------
 src/dysh/spectra/obsblock.py                 |  33 +-
 src/dysh/spectra/scan.py                     | 429 +++++++------
 src/dysh/spectra/spectrum.py                 | 215 +++----
 src/dysh/spectra/tests/test_core.py          |  29 +-
 src/dysh/spectra/tests/test_scan.py          |  46 +-
 src/dysh/util/core.py                        |  53 +-
 src/dysh/util/files.py                       |  61 +-
 src/dysh/util/tests/test_wget.py             |   6 +-
 47 files changed, 2312 insertions(+), 1895 deletions(-)

diff --git a/README.md b/README.md
index 09c95db3..bb8508b3 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 ## Getting Started
 ### Installation
 
-Dysh requires Python 3.8+ and recent versions of [astropy]( https://astropy.org), [numpy](https://numpy.org), [scipy](https://scipy.org), [pandas](https://pandas.pydata.org), [specutils](https://specutils.readthedocs.io/en/stable/),  and [matplotlib](https://matplotlib.org). 
+Dysh requires Python 3.8+ and recent versions of [astropy]( https://astropy.org), [numpy](https://numpy.org), [scipy](https://scipy.org), [pandas](https://pandas.pydata.org), [specutils](https://specutils.readthedocs.io/en/stable/),  and [matplotlib](https://matplotlib.org).
 
 #### With pip from PyPi
 Dysh is most easily installed with *pip*, which will take care of any dependencies.  The packaged code is hosted at the [Python Packaging Index](https://pypi.org/project/dysh).
@@ -15,7 +15,7 @@ Dysh is most easily installed with *pip*, which will take care of any dependenci
 ```
 
 #### From github
-To install from github without creating a separate virtual environment: 
+To install from github without creating a separate virtual environment:
 
 ```bash
     $ git clone git@github.com:GreenBankObservatory/dysh.git
@@ -64,7 +64,7 @@ The virtual environment will be created the first time; subsequent invoking ``ha
 
 ```bash
     (dysh) $ exit
-    $ 
+    $
 ```
 
 4.  Each time when you come back in this directory without being in this virtual environment, you'll need to load the virtual environment
@@ -80,4 +80,3 @@ The virtual environment will be created the first time; subsequent invoking ``ha
 ```bash
     $ pytest
 ```
-
diff --git a/attic/sdfitsload.py b/attic/sdfitsload.py
index 52bd314a..74b091b4 100644
--- a/attic/sdfitsload.py
+++ b/attic/sdfitsload.py
@@ -1,68 +1,60 @@
 #!/usr/bin/env python
 import sys
-import copy
+
+import astropy.units as u
+import matplotlib.pyplot as plt
 import numpy as np
-from astropy.wcs import WCS
-from astropy.units import cds
-from astropy.modeling.models import Gaussian1D
-from astropy.modeling.polynomial import Polynomial1D
 from astropy.io import fits
-from astropy.modeling import models, fitting
-import astropy.units as u
+from astropy.modeling.fitting import LinearLSQFitter
+from astropy.modeling.polynomial import Polynomial1D
 from astropy.table import Table
-from astropy.modeling.fitting import LevMarLSQFitter,LinearLSQFitter
-from specutils import Spectrum1D, SpectrumList,SpectralRegion
+from astropy.units import cds
+from astropy.wcs import WCS
+from specutils import Spectrum1D, SpectrumList
 from specutils.fitting import fit_continuum
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from scipy.optimize import leastsq
 
-def baseline(speclist,order,exclude=None,plot=False,maxspec=1000,scipy=False):
-    #last = min(len(speclist),maxspec)
+
+def baseline(speclist, order, exclude=None, plot=False, maxspec=1000, scipy=False):
+    # last = min(len(speclist),maxspec)
     print(f"BL {order} for {len(speclist)} spectra")
-    #for p in speclist[0:last]:
-    i=0
+    # for p in speclist[0:last]:
+    i = 0
     bad = 0
     model = Polynomial1D(degree=order)
     fitter = LinearLSQFitter(calc_uncertainties=True)
-    #fitter = LevMarLSQFitter(calc_uncertainties=True)
+    # fitter = LevMarLSQFitter(calc_uncertainties=True)
     print(f"MODEL {model} FITTER {fitter}")
     try:
         if exclude is not None:
             for p in speclist:
                 if np.isnan(p.data).all():
-                    bad+=1
+                    bad += 1
                     continue
-                fc = fit_continuum(spectrum=p,
-                        model=model,
-                        fitter=fitter,
-                        exclude_regions=[exclude])
-                i=i+1
+                fc = fit_continuum(spectrum=p, model=model, fitter=fitter, exclude_regions=[exclude])
+                i = i + 1
         else:
             for p in speclist:
                 if np.isnan(p.data).all():
-                    bad+=1
+                    bad += 1
                     continue
-                fc = fit_continuum(spectrum=p,
-                        model=model,
-                        fitter=fitter)
-                i=i+1
+                fc = fit_continuum(spectrum=p, model=model, fitter=fitter)
+                i = i + 1
     except Exception as e:
         print(f"At spectrum {i}, Exception was {e}")
         print(p)
-        print("DATA MEAN: ",np.nanmean(p.data))
+        print("DATA MEAN: ", np.nanmean(p.data))
         return p
     if plot:
-        fig,ax = plt.subplots()
-        ax.plot(x,p.flux)
-        ax.plot(x,fc(x))
+        fig, ax = plt.subplots()
+        ax.plot(x, p.flux)
+        ax.plot(x, fc(x))
         plt.show()
     print(f"NUMBER OF BAD SPECTRA: {bad}")
     return None
 
+
 def get_size(obj, seen=None):
-    #https://goshippo.com/blog/measure-real-size-any-python-object/
+    # https://goshippo.com/blog/measure-real-size-any-python-object/
     """Recursively finds size of objects"""
     size = sys.getsizeof(obj)
     if seen is None:
@@ -76,35 +68,35 @@ def get_size(obj, seen=None):
     if isinstance(obj, dict):
         size += sum([get_size(v, seen) for v in obj.values()])
         size += sum([get_size(k, seen) for k in obj.keys()])
-    elif hasattr(obj, '__dict__'):
+    elif hasattr(obj, "__dict__"):
         size += get_size(obj.__dict__, seen)
-    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes, bytearray)):
         size += sum([get_size(i, seen) for i in obj])
     return size
 
 
 def dcmeantsys(calon, caloff, tcal, mode=0, fedge=10, nedge=None):
     """
-    following the GBTIDL routine with same name, get the tsys from 
-    the neighboring calon and caloff we define an extra way to set 
+    following the GBTIDL routine with same name, get the tsys from
+    the neighboring calon and caloff we define an extra way to set
     the edge size, nedge, if you prefer to use number of edge channels
     instead of the inverse fraction
-    
+
     calon/caloff is meant to reflect the state of the noise diode
-    
+
     mode=0     do the mean before the division
     mode=1     do the mean after the division
     """
     nchan = len(calon)
-    if nedge == None:
-        nedge = nchan // fedge     # 10 %
+    if nedge is None:
+        nedge = nchan // fedge  # 10 %
     if mode == 0:
         meanoff = np.mean(caloff[nedge:-nedge])
         meandiff = np.mean(calon[nedge:-nedge] - caloff[nedge:-nedge])
-        meanTsys = ( meanoff / meandiff * tcal + tcal/2.0 )
+        meanTsys = meanoff / meandiff * tcal + tcal / 2.0
     else:
-        meanTsys = np.mean( caloff[nedge:-nedge] / (calon[nedge:-nedge] - caloff[nedge:-nedge]) )
-        meanTsys = meanTsys * tcal + tcal/2.0
+        meanTsys = np.mean(caloff[nedge:-nedge] / (calon[nedge:-nedge] - caloff[nedge:-nedge]))
+        meanTsys = meanTsys * tcal + tcal / 2.0
     return meanTsys
 
 
@@ -112,10 +104,10 @@ def dcmeantsys(calon, caloff, tcal, mode=0, fedge=10, nedge=None):
 
 
 def uniq(seq):
-    """ from http://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-python-whilst-preserving-order """
+    """from http://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-python-whilst-preserving-order"""
     seen = set()
     seen_add = seen.add
-    return [ x for x in seq if x not in seen and not seen_add(x)]
+    return [x for x in seq if x not in seen and not seen_add(x)]
 
 
 def sonoff(scan, procseqn):
@@ -124,99 +116,101 @@ def sonoff(scan, procseqn):
     there must be a more elegant python way to do this....
     """
     sp = {}
-    for (i,j) in zip(scan, procseqn):
+    for i, j in zip(scan, procseqn):
         sp[i] = j
-    
+
     us1 = uniq(scan)
     up1 = uniq(procseqn)
-    
+
     sd = {}
     for i in up1:
         sd[i] = []
-        
+
     for s in us1:
         sd[sp[s]].append(s)
 
     return sd
 
 
-class Obsblock():
-    '''Class that holds a series of spectra on which bulk operations can be performed'''
-    def __init__(self,speclist,index):
+class Obsblock:
+    """Class that holds a series of spectra on which bulk operations can be performed"""
+
+    def __init__(self, speclist, index):
         self._speclist = speclist
-        self._index = index # pandas dataframe
+        self._index = index  # pandas dataframe
 
-    def __getitem__(self,i):
+    def __getitem__(self, i):
         return self._speclist[i]
 
     def __len__(self):
         return len(self._speclist)
 
-    def __op__(self,opname):
+    def __op__(self, opname):
         pass
 
 
 # # SDFITSLoad
-# 
+#
 # This is the class that loads an SDFITS file. Normally not called by users, but by classes such as GBTLoadPS()
-# 
-# 
+#
+#
 
 # In[334]:
 
 
 class SDFITSLoad(object):
-    '''
+    """
     Container for a bintable(s) from selected HDU(s)
-    '''
+    """
+
     def __init__(self, filename, source=None, hdu=None, **kwargs):
-        """
-        """
+        """ """
         print("==SDFITSLoad %s" % filename)
         cds.enable()  # to get mmHg
-        kwargs_opts = {'fix':False}
-        kwargs_opts = {'wcs':False}
+        kwargs_opts = {"fix": False}
+        kwargs_opts = {"wcs": False}
         kwargs_opts.update(kwargs)
         self._filename = filename
         self._bintable = []
         self._ptable = []
         self._binheader = []
         self._data = []
-        self._obsblock = [] # list of SpecList
-        self._hdu = fits.open(filename)  
+        self._obsblock = []  # list of SpecList
+        self._hdu = fits.open(filename)
         self._header = self._hdu[0].header
-        self.load(hdu,**kwargs_opts)
-        #self.load_pandas()
-        #self._hdu.close()  # can't access hdu[i].data member of you do this.
-    @property 
+        self.load(hdu, **kwargs_opts)
+        # self.load_pandas()
+        # self._hdu.close()  # can't access hdu[i].data member of you do this.
+
+    @property
     def filename(self):
         return self._filename
-    
-    def reset(self,hdu=None):
+
+    def reset(self, hdu=None):
         self._bintable = []
         self._binheader = []
         self._ptable = []
         self._data = []
         self._spectra = []
-        self._hdu = fits.open(self._filename)  
+        self._hdu = fits.open(self._filename)
         self._header = self._hdu[0].header
-        #if hdu is not None:
-         #   self.load(src,hdu)
-    
-    def load_pandas(self,hdu=None):
+        # if hdu is not None:
+        #   self.load(src,hdu)
+
+    def load_pandas(self, hdu=None):
         if hdu is not None:
             ldu = list([hdu])
         else:
-            ldu = range(1,len(self._hdu))
+            ldu = range(1, len(self._hdu))
         self._ptable = []
         for i in ldu:
-            t = Table.read(self._hdu[i]) 
-            t.remove_column('DATA')
+            t = Table.read(self._hdu[i])
+            t.remove_column("DATA")
             self.stripT(t)
             print(f"doing pandas for HDU {i}")
             self._ptable.append(t.to_pandas())
             del t
-            
+
     def load(self, hdu=None, **kwargs):
         """
         for given hdu make this bintable available
@@ -228,23 +222,23 @@ def load(self, hdu=None, **kwargs):
         self._binheader = []
         self._data = []
         self._nrows = []
-        source = kwargs.get('source',None)
-        fix = kwargs.get('fix',False)
-        wcs = kwargs.get('wcs',False)
+        kwargs.get("source", None)
+        kwargs.get("fix", False)
+        kwargs.get("wcs", False)
 
         if hdu is not None:
             ldu = list([hdu])
         else:
-            ldu = range(1,len(self._hdu))
+            ldu = range(1, len(self._hdu))
         for i in ldu:
-            j=i-1
-            self._bintable.append(self._hdu[i]) 
+            j = i - 1
+            self._bintable.append(self._hdu[i])
             self._binheader.append(self._hdu[i].header)
             # TODO: don't allow preselection here, it just screws bookkeepingu p.
             # All selection must happen in obsblocks.
-            #if source is None:
-            #self._data.append(self._bintable[j].data[:]["DATA"])
-            #else:
+            # if source is None:
+            # self._data.append(self._bintable[j].data[:]["DATA"])
+            # else:
             #    wh1 = np.char.strip(self._bintable[j]['OBJECT']) == source # true/false array
             #    if wh1.sum() == 0: #all False none found
             #        srcs = np.unique(self._bintable[j]['OBJECT'])
@@ -254,210 +248,235 @@ def load(self, hdu=None, **kwargs):
             #    self._bintable[j] = self._bintable[j][mask]  # header will be wrong?
             self._nrows.append(self._binheader[j]["NAXIS2"])
 
-        if kwargs.get("index",False):
+        if kwargs.get("index", False):
             self.load_pandas(hdu)
 
-    def stripT(self,b):
-        # remove leading and trailing chars from all strings in table 
+    def stripT(self, b):
+        # remove leading and trailing chars from all strings in table
         for n in b.colnames:
-            if np.issubdtype(b.dtype[n],str):
+            if np.issubdtype(b.dtype[n], str):
                 b[n] = np.char.strip(b[n])
 
     def strip(self):
-        # remove leading and trailing chars from all strings in table 
+        # remove leading and trailing chars from all strings in table
         for b in self._ptable:
             for n in b.colnames:
-                if np.issubdtype(b.dtype[n],str):
+                if np.issubdtype(b.dtype[n], str):
                     b[n] = np.char.strip(b[n])
 
-    def _loadlists(self,hdu,fix=False,wcs=False,maxspect=1E16):
+    def _loadlists(self, hdu, fix=False, wcs=False, maxspect=1e16):
         self._obsblock = []
-        i=0
+        i = 0
         k = -1
-        print("HDU = ",hdu)
+        print("HDU = ", hdu)
         if hdu is not None:
-            b = self._ptable[hdu-1]
+            b = self._ptable[hdu - 1]
             rawspect = self._bintable[i].data["DATA"]
             sl = SpectrumList()
-            maxload = int(np.min([maxspect,self.nrows(i)]))
-            print(f"Creating {maxload} Spectrum1D in bintable {i} HDU {hdu}",file=sys.stderr)
+            maxload = int(np.min([maxspect, self.nrows(i)]))
+            print(f"Creating {maxload} Spectrum1D in bintable {i} HDU {hdu}", file=sys.stderr)
             for j in range(maxload):
-                k = k+1
+                k = k + 1
                 # need extra [[]] because we have 1x1 spatial NAXIS
                 # otherwise, slicing the spectrum won't work.
-                if wcs: 
-                    sp = np.array([[self.rawspectrum(i,j)]])
+                if wcs:
+                    sp = np.array([[self.rawspectrum(i, j)]])
                 else:
-                    #sp = self.rawspectrum(i,j)*u.K
-                    sp = np.copy(rawspect[j])#*u.K
-                    #sp = np.random.rand(32768)*u.K
-                naxis1 =  sp.shape[0]#self.nchan(i)
-                printme = int(0.1*len(b))
-                if (k%printme) == 0: 
+                    # sp = self.rawspectrum(i,j)*u.K
+                    sp = np.copy(rawspect[j])  # *u.K
+                    # sp = np.random.rand(32768)*u.K
+                naxis1 = sp.shape[0]  # self.nchan(i)
+                printme = int(0.1 * len(b))
+                if (k % printme) == 0:
                     print(f"Row {k} nchan {naxis1} {type(sp)}", file=sys.stderr)
-                    #print(f"NAXIS1 is {naxis1}",file=sys.stderr)
-                crval1  = b['CRVAL1'][j]
-                cdelt1  = b['CDELT1'][j]
-                crpix1  = b['CRPIX1'][j]
-                ctype1  = b['CTYPE1'][j]
+                    # print(f"NAXIS1 is {naxis1}",file=sys.stderr)
+                crval1 = b["CRVAL1"][j]
+                cdelt1 = b["CDELT1"][j]
+                crpix1 = b["CRPIX1"][j]
+                b["CTYPE1"][j]
                 # Ensure rest frequency is in Hertz
                 # CUNIT1 is not always present
-                restfrq = b['RESTFREQ'][j]
+                restfrq = b["RESTFREQ"][j]
                 if "CUNIT1" in b.columns:
-                    cunit1  = b['CUNIT1'][j]
+                    cunit1 = b["CUNIT1"][j]
                     rfq = restfrq * u.Unit(cunit1)
-                    restfreq = rfq.to("Hz").value
+                    rfq.to("Hz").value
                 cunit1 = "Hz"
-                crval2  = b['CRVAL2'][j]
-                crval3  = b['CRVAL3'][j]
-                ctype2  = b['CTYPE2'][j]
-                ctype3  = b['CTYPE3'][j]
+                crval2 = b["CRVAL2"][j]
+                crval3 = b["CRVAL3"][j]
+                ctype2 = b["CTYPE2"][j]
+                ctype3 = b["CTYPE3"][j]
                 # 'FREQ-OBS' to 'FREQ'; assuming SPECSYS='TOPOCENT'
-                #if ctype1 == 'FREQ-OBS': ctype1  = 'FREQ'
+                # if ctype1 == 'FREQ-OBS': ctype1  = 'FREQ'
                 # only axis1 needs a full description, axis2,3,4 are all single points
                 if wcs:
-                    wcs = WCS(header={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfrq,
-                                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1
-                                     },
-                             fix=fix)
+                    wcs = WCS(
+                        header={
+                            "CDELT1": cdelt1,
+                            "CRVAL1": crval1,
+                            "CUNIT1": cunit1,
+                            "CTYPE1": "FREQ",
+                            "CRPIX1": crpix1,
+                            "RESTFRQ": restfrq,
+                            "CTYPE2": ctype2,
+                            "CRVAL2": crval2,
+                            "CRPIX2": 1,
+                            "CTYPE3": ctype3,
+                            "CRVAL3": crval3,
+                            "CRPIX3": 1,
+                            "CUNIT2": "deg",
+                            "CUNIT3": "deg",
+                            "NAXIS1": naxis1,
+                            "NAXIS2": 1,
+                            "NAXIS3": 1,
+                        },
+                        fix=fix,
+                    )
                 else:
                     wcs = None
                 # GBT really fucks up FREQ/VELDEF/VELFRAME
-                #if False:
+                # if False:
                 if "VELFRAME" in b.columns:
-                    vframe = b['VELFRAME'][j]
+                    vframe = b["VELFRAME"][j]
                 elif "VFRAME" in b.columns:
-                    vframe = b['VFRAME'][j]
+                    vframe = b["VFRAME"][j]
                 else:
                     vframe = None
                 if "VELDEF" in b.columns:
-                    vdef = b['VELDEF'][j]
+                    vdef = b["VELDEF"][j]
                 else:
                     vdef = None
 
-                meta={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfrq,
-                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1,
-                      'VELDEF': vdef, 'VELFRAME': vframe
-                     }
-
-                convention = self.velocity_convention(vdef,vframe)
-                #meta = dict(b.loc[j])# Necessary? Since we are sending whole pandas table to Obsblock
+                meta = {
+                    "CDELT1": cdelt1,
+                    "CRVAL1": crval1,
+                    "CUNIT1": cunit1,
+                    "CTYPE1": "FREQ",
+                    "CRPIX1": crpix1,
+                    "RESTFRQ": restfrq,
+                    "CTYPE2": ctype2,
+                    "CRVAL2": crval2,
+                    "CRPIX2": 1,
+                    "CTYPE3": ctype3,
+                    "CRVAL3": crval3,
+                    "CRPIX3": 1,
+                    "CUNIT2": "deg",
+                    "CUNIT3": "deg",
+                    "NAXIS1": naxis1,
+                    "NAXIS2": 1,
+                    "NAXIS3": 1,
+                    "VELDEF": vdef,
+                    "VELFRAME": vframe,
+                }
+
+                convention = self.velocity_convention(vdef, vframe)
+                # meta = dict(b.loc[j])# Necessary? Since we are sending whole pandas table to Obsblock
                 if fix:
                     self.fix_meta(meta)
                 if False:
                     try:
-                        convention = self.velocity_convention(meta['VELDEF'],meta['VELFRAME'])
+                        convention = self.velocity_convention(meta["VELDEF"], meta["VELFRAME"])
                     except Exception:
-                        #print("WARNING: insufficient veldef/velframe, assuming convention is 'doppler_radio'")
-                        convention="doppler_radio"
+                        # print("WARNING: insufficient veldef/velframe, assuming convention is 'doppler_radio'")
+                        convention = "doppler_radio"
                 meta = {}
-                sl.append(Spectrum1D(flux=sp*u.K,wcs=wcs,  meta=meta, velocity_convention=convention))
-            self._obsblock.append(Obsblock(sl,self._ptable[i]))
-            i=i+1
+                sl.append(Spectrum1D(flux=sp * u.K, wcs=wcs, meta=meta, velocity_convention=convention))
+            self._obsblock.append(Obsblock(sl, self._ptable[i]))
+            i = i + 1
 
-
-    def fix_meta(self,meta):
+    def fix_meta(self, meta):
         """Do any repair to the meta/header for peculariaties in definitions from a particular observatory
         The passed-in dictionary will be repaired in place.
         At minimum this method must populate meta['VELDEF'] and meta['VELFRAME']
         """
         pass
-    
-    def velocity_convention(self,veldef,velframe):
+
+    def velocity_convention(self, veldef, velframe):
         # sub-classes must implement this so I can keep this class generic.
-        # GBT uses VELDEF and VELFRAME incorrectly. 
+        # GBT uses VELDEF and VELFRAME incorrectly.
         return "doppler_radio"
-    
-    def udata(self,bintable,key):
+
+    def udata(self, bintable, key):
         return uniq(self._data[bintable][key])
-                                  
-    def ushow(self,bintable,key):
-        print(f'{bintable} {key}: {self.udata(bintable,key)}')
-        
-    def naxis(self,bintable,naxis):
-        nax = f'NAXIS{naxis}'
+
+    def ushow(self, bintable, key):
+        print(f"{bintable} {key}: {self.udata(bintable,key)}")
+
+    def naxis(self, bintable, naxis):
+        nax = f"NAXIS{naxis}"
         return self._binheader[bintable][nax]
-    
-    def nintegrations(self,bintable,source=None):
+
+    def nintegrations(self, bintable, source=None):
         if source is not None:
-            nint = np.shape(np.char.strip(self._data[bintable]['OBJECT']) == source)[0]//self.npol(bintable)
+            nint = np.shape(np.char.strip(self._data[bintable]["OBJECT"]) == source)[0] // self.npol(bintable)
         else:
-            nint = np.shape(self._data[bintable])[0]//self.npol(bintable)
+            nint = np.shape(self._data[bintable])[0] // self.npol(bintable)
         return nint
 
-    def rawspectra(self,bintable):
+    def rawspectra(self, bintable):
         return self._bintable[bintable].data[:]["DATA"]
 
-    def rawspectrum(self,bintable,i):
+    def rawspectrum(self, bintable, i):
         return self._bintable[bintable].data[:]["DATA"][i]
-    
-    def nrows(self,bintable):
+
+    def nrows(self, bintable):
         return self._nrows[bintable]
 
-    def nchan(self,bintable):
-        return np.shape(self.rawspectrum(bintable,1))[0]
-    
-    def npol(self,bintable):
-        return len(self.udata(bintable,'CRVAL4'))
-    
-    def sources(self,bintable):
-        return self.udata(bintable,'OBJECT')
-    
-    def scans(self,bintable):
-        return self.ushow(bintable,'SCAN')
-    
+    def nchan(self, bintable):
+        return np.shape(self.rawspectrum(bintable, 1))[0]
+
+    def npol(self, bintable):
+        return len(self.udata(bintable, "CRVAL4"))
+
+    def sources(self, bintable):
+        return self.udata(bintable, "OBJECT")
+
+    def scans(self, bintable):
+        return self.ushow(bintable, "SCAN")
+
     def __len__(self):
         return self.nrows
-    
-    def _summary(self,bintable):
-        j=bintable
-        nrows = self.naxis(j,2)
-        nflds = self._binheader[j]['TFIELDS']
-        restfreq = np.unique(self._data[j]['RESTFREQ'])/1.0E9
-    #
-        print("HDU       %d" %  (j+1))
-        print("BINTABLE: %d rows x %d cols with %d chans" % (self._nrows[j],nflds,self.nchan(j)))
-        print("Selected  %d/%d rows" % (self._nrows[j],nrows))
-        print("Sources: ",self.sources(j))
-        print("RESTFREQ:",restfreq,'GHz')
-        print("Scans:   ",self.scans(j))
-        print("Npol:    ",self.npol(j))   
-        print("Nint:    ",self.nintegrations(j))
-        
+
+    def _summary(self, bintable):
+        j = bintable
+        nrows = self.naxis(j, 2)
+        nflds = self._binheader[j]["TFIELDS"]
+        restfreq = np.unique(self._data[j]["RESTFREQ"]) / 1.0e9
+        #
+        print("HDU       %d" % (j + 1))
+        print("BINTABLE: %d rows x %d cols with %d chans" % (self._nrows[j], nflds, self.nchan(j)))
+        print("Selected  %d/%d rows" % (self._nrows[j], nrows))
+        print("Sources: ", self.sources(j))
+        print("RESTFREQ:", restfreq, "GHz")
+        print("Scans:   ", self.scans(j))
+        print("Npol:    ", self.npol(j))
+        print("Nint:    ", self.nintegrations(j))
+
     def summary(self):
-        print("File:     %s"%self._filename)
+        print("File:     %s" % self._filename)
         for i in range(len(self._bintable)):
             self._summary(i)
-    
-    def __repr__(self):
-        return self._filename    
 
+    def __repr__(self):
+        return self._filename
 
 
 class GBTLoad(SDFITSLoad):
-    def __init__(self, filename, src=None,hdu=None):
+    def __init__(self, filename, src=None, hdu=None):
         """
         Holds a raw "unstructured" series of scans, normally not used by users
-        """       
-        SDFITSLoad.__init__(self,filename,src,hdu,fix=False)
+        """
+        SDFITSLoad.__init__(self, filename, src, hdu, fix=False)
         print("==GBTLoad %s" % filename)
 
-        self.ushow(0,'OBJECT')
-        self.ushow(0,'SCAN')
-        self.ushow(0,'SAMPLER')
-        #ushow('PLNUM')
-        #ushow('IFNUM')
-        self.ushow(0,'SIG')
-        self.ushow(0,'CAL')
-        self.ushow(0,'PROCSEQN')
-        self.ushow(0,'PROCSIZE')
-        self.ushow(0,'OBSMODE')  
-        self.ushow(0,'SIDEBAND')
+        self.ushow(0, "OBJECT")
+        self.ushow(0, "SCAN")
+        self.ushow(0, "SAMPLER")
+        # ushow('PLNUM')
+        # ushow('IFNUM')
+        self.ushow(0, "SIG")
+        self.ushow(0, "CAL")
+        self.ushow(0, "PROCSEQN")
+        self.ushow(0, "PROCSIZE")
+        self.ushow(0, "OBSMODE")
+        self.ushow(0, "SIDEBAND")
diff --git a/attic/test_s1d.py b/attic/test_s1d.py
index f8c21295..50908c65 100644
--- a/attic/test_s1d.py
+++ b/attic/test_s1d.py
@@ -1,63 +1,66 @@
-import numpy as np
-from specutils import Spectrum1D, SpectrumList, SpectralRegion
-from specutils.fitting import fit_continuum
+import gc
+import resource
+import sys
+
 import astropy.units as u
-from astropy.modeling.models import Gaussian1D
-from astropy.modeling.polynomial import Polynomial1D
-from memory_profiler import profile
 import matplotlib.pyplot as plt
-import sys
-import resource
-import gc
+import numpy as np
 import objgraph
+from astropy.modeling.models import Gaussian1D
+from astropy.modeling.polynomial import Polynomial1D
+from specutils import SpectralRegion, Spectrum1D, SpectrumList
+from specutils.fitting import fit_continuum
+
 
-#@profile
-def testit(nchan,num):
+# @profile
+def testit(nchan, num):
     # Make no difference if use spectrumlist or []
     if False:
         sl = SpectrumList()
     else:
         sl = []
-    #default size 
+    # default size
     raw = np.random.rand(nchan)
-    rawsize=sys.getsizeof(raw)
-    blocksize=rawsize*num
-    x = np.linspace(0,10,nchan)
-    g1 = Gaussian1D(amplitude=10,mean=5,stddev=0.3)
+    rawsize = sys.getsizeof(raw)
+    blocksize = rawsize * num
+    x = np.linspace(0, 10, nchan)
+    g1 = Gaussian1D(amplitude=10, mean=5, stddev=0.3)
     print(f"Size of single {nchan} channel spectrum {rawsize/(1024*1024):.2} Mbytes")
     print(f"X {num} = {blocksize} bytes = {blocksize/(1048576*1024):.2} GB")
     for j in range(num):
-        if j%500 == 0:
+        if j % 500 == 0:
             print(f"doing row {j}")
-        sp = (20.+g1(x)+np.random.normal(size=nchan))*u.K
-        p=Spectrum1D(flux=sp, spectral_axis=x*u.um,wcs=None,meta={},velocity_convention="doppler_radio")
+        sp = (20.0 + g1(x) + np.random.normal(size=nchan)) * u.K
+        p = Spectrum1D(flux=sp, spectral_axis=x * u.um, wcs=None, meta={}, velocity_convention="doppler_radio")
         sl.append(p)
     return sl
 
-def baseline(speclist,order,exclude=None,plot=False):
-    fc = fit_continuum(p,Polynomial1D(degree=order),exclude_regions=[exclude])
+
+def baseline(speclist, order, exclude=None, plot=False):
+    fc = fit_continuum(p, Polynomial1D(degree=order), exclude_regions=[exclude])
     if plot:
-        fig,ax = plt.subplots()
-        ax.plot(x,p.flux)
-        ax.plot(x,fc(x))
+        fig, ax = plt.subplots()
+        ax.plot(x, p.flux)
+        ax.plot(x, fc(x))
         plt.show()
 
+
 if __name__ == "__main__":
-    sl=testit(nchan=2048,num=2000)
-    print(f'Memory usage: %s (Gb) {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/(1024*1024)}')
+    sl = testit(nchan=2048, num=2000)
+    print(f"Memory usage: %s (Gb) {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/(1024*1024)}")
     gc.collect()
-    print(f'Post-GC Memory usage: %s (Gb) {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/(1024*1024)}')
+    print(f"Post-GC Memory usage: %s (Gb) {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/(1024*1024)}")
     objgraph.show_most_common_types()
     p = sl[0]
     x = sl[0].spectral_axis
     nchan = len(x)
-    cdelt = x[1]-x[0]
+    cdelt = x[1] - x[0]
     center = x[nchan // 2]
-    width = 0.25*nchan*cdelt
-    exclude = SpectralRegion.from_center(center,width)
-    i=0
+    width = 0.25 * nchan * cdelt
+    exclude = SpectralRegion.from_center(center, width)
+    i = 0
     for sp in sl:
-        if (i%500) == 0:
-            print("baseline ",i)
-        baseline(sp,1,exclude)
-        i=1+i
+        if (i % 500) == 0:
+            print("baseline ", i)
+        baseline(sp, 1, exclude)
+        i = 1 + i
diff --git a/benchmark/README.md b/benchmark/README.md
index ebc0fc36..d8813c3f 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -1,12 +1,12 @@
 # Notes for benchmarking Dysh
 
-The purpose of  benchmarking is to test performance  of 
+The purpose of  benchmarking is to test performance  of
 
-- opening/loading an SDFITS file/hdu 
+- opening/loading an SDFITS file/hdu
 - optionally creating an index of some sort (GBTIDL or pandas)
 - creating spectra from each DATA row of the SDFITS table.
 - remove baselines of order 1, 2, and 3 from each spectrum.
- 
+
 Timing is 'wall clock time', i.e., it includes and kernel/sleep operations.  In python, we are using  *time.perfcounter_ns()*
 
 ## Avoiding File caching
@@ -22,7 +22,7 @@ The OMP_NUM_THREADS environment variable sets the number of threads to use for
 and
     setenv OMP_NUM_THREADS 1
 
-## SDFITS Files 
+## SDFITS Files
 
 The standard set of SDFITS files to run the benchmark on are in /lma1/mpound/GBT/examples/ on LMA machines and /home/scratch/mpound/examples in GBO machines.  The files are (in ascending order of size):
 
@@ -33,7 +33,7 @@ The standard set of SDFITS files to run the benchmark on are in /lma1/mpound/GBT
 - onoff-L/data/TGBT21A_501_11.raw.vegas.fits
 - mapping-L/data/TGBT17A_506_11.raw.vegas/
 TGBT17A_506_11.raw.vegas.A.fits
-- nod-KFPA/data/TGBT22A_503_02.raw.vegas/TGBT22A_503_02.raw.vegas.F.fits 
+- nod-KFPA/data/TGBT22A_503_02.raw.vegas/TGBT22A_503_02.raw.vegas.F.fits
 - mixed-fs-ps/data/AGBT16B_225_05/AGBT16B_225_05.raw.vegas/AGBT16B_225_05.raw.vegas.B.fits
 
 ## Code details
@@ -41,7 +41,7 @@ TGBT17A_506_11.raw.vegas.A.fits
 2. The python benchmark code is *revisedstructure.py* and is invoked with *benchmark_py.csh*
     -  To run it, you have to have dysh installed.  This is done with hatch and I haven't written up the notes for that yet!
     - It has various options to turn on/off pieces of the benchmark, see *revisedstructure.py -h*
- 
+
 ## Output
 Output should be into a (IPAC-formatted) table with the following columns:
 
@@ -50,7 +50,7 @@ Output should be into a (IPAC-formatted) table with the following columns:
 - N_hdu - number of HDU in the file
 - HDU - number of the HDU for which this row contains the benchmark
 - N_rows - number of rows in this HDU
-- N_chan - number of chan per spectum in this HDU  
+- N_chan - number of chan per spectum in this HDU
 - Load - time to load/read the SDFITs file, in ms .  e.g. astropy.io.fits.open()
 - Index - time to create index (e.g. pandas, GBTIDL) in ms
 - Create_Obslocks - time to create Spectrum object for every row of HDU, in ms
@@ -62,4 +62,3 @@ The python script *makeplots.py* will make some standard  plots given the IPAC f
 
     ./makeplots.py -f tab_omp=1.out -t "Timing for Load/Obsblocks/Baseline (OMP=1)" -o t1.png
     ./makeplots.py -f tab_omp_unset.out -t "Timing for Load/Obsblocks/Baseline (OMP unset)" -o t2.png
-
diff --git a/benchmark/benchmark_py.csh b/benchmark/benchmark_py.csh
index 368430c4..298c5339 100755
--- a/benchmark/benchmark_py.csh
+++ b/benchmark/benchmark_py.csh
@@ -2,7 +2,7 @@
 #set path = ( . $path )
 #
 # BE sure to echo 1 > /proc/sys/vm/drop_caches before running this.
-unsetenv OMP_NUM_THREADS 
+unsetenv OMP_NUM_THREADS
 set root = "/data/gbt/examples/"
 #set root = "/lma1/mpound/GBT/examples/"
 #set root = "/home/scratch/mpound/examples/"
diff --git a/benchmark/makeplots.py b/benchmark/makeplots.py
index 01b6fde2..8268a4b5 100755
--- a/benchmark/makeplots.py
+++ b/benchmark/makeplots.py
@@ -1,13 +1,14 @@
 #!/usr/bin/env python
-from astropy.table import Table
+import argparse
+
 import matplotlib.pyplot as plt
 import numpy as np
-import pandas as pd
-from matplotlib.ticker import FormatStrFormatter
-import argparse
+from astropy.table import Table
+
 
-def add_patch(legend,fc,label):
+def add_patch(legend, fc, label):
     from matplotlib.patches import Patch
+
     ax = legend.axes
 
     handles, labels = ax.get_legend_handles_labels()
@@ -21,157 +22,201 @@ def add_patch(legend,fc,label):
     legend.set_title(legend.get_title().get_text())
     return legend
 
+
 def lineplots(file):
-    t = Table.read(file,format='ipac')
-    colors = ['red', 'tan', 'lime']
-    df = t.to_pandas()#.sort_values('N_rows')
-    time_cols = ['Load','Index', 'Create_Obsblocks' ,'Baseline_1','Baseline_2','Baseline_3']
-    tc = [ s.replace('_',' ') for s in time_cols ]
-    size_col = 'Size'
+    t = Table.read(file, format="ipac")
+    df = t.to_pandas()  # .sort_values('N_rows')
+    time_cols = ["Load", "Index", "Create_Obsblocks", "Baseline_1", "Baseline_2", "Baseline_3"]
+    [s.replace("_", " ") for s in time_cols]
+    size_col = "Size"
     df[time_cols] /= 1000.0
     df[size_col] = np.rint(df[size_col]).astype(int)
-    fig,ax = plt.subplots(3,2,figsize=(10,10))
-    df = df.sort_values('Size')
+    fig, ax = plt.subplots(3, 2, figsize=(10, 10))
+    df = df.sort_values("Size")
     axf = ax.flatten()
     axindex = 0
-    axf[axindex].plot(df['Load'],df[size_col],
-        marker='o',markersize=12,linewidth=2,label='Load File')
+    axf[axindex].plot(df["Load"], df[size_col], marker="o", markersize=12, linewidth=2, label="Load File")
     axf[axindex].set_ylabel("File Size (MB)")
-    axindex+=1
-    axf[axindex].plot(df['Index'],df[size_col],
-        marker='+',markersize=12,linewidth=2,label='Index File')
+    axindex += 1
+    axf[axindex].plot(df["Index"], df[size_col], marker="+", markersize=12, linewidth=2, label="Index File")
     axf[axindex].set_ylabel("File Size (MB)")
-    #df = df.sort_values('N_chan')
-    #axf[2].plot(df['Create_Obsblocks'],df['N_chan'],
+    # df = df.sort_values('N_chan')
+    # axf[2].plot(df['Create_Obsblocks'],df['N_chan'],
     #    marker='>',markersize=12,linewidth=2,label='Create Obsblocks')
-    df['multi'] = df['N_chan']*df['N_rows']/1E8
-    df = df.sort_values('multi')
-    axindex+=1
-    l1 = axf[axindex].plot(df['Create_Obsblocks'],df['multi'],
-        marker='^',markersize=12,linewidth=2,
-        label='Create Obsblocks (scaled)')
+    df["multi"] = df["N_chan"] * df["N_rows"] / 1e8
+    df = df.sort_values("multi")
+    axindex += 1
+    l1 = axf[axindex].plot(
+        df["Create_Obsblocks"], df["multi"], marker="^", markersize=12, linewidth=2, label="Create Obsblocks (scaled)"
+    )
     axf[axindex].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
     ax2 = axf[axindex].twinx()
     ax2.set_ylabel(r"$N_{rows}$")
-    l2 = ax2.plot(df['Create_Obsblocks'],df['N_rows'],
-        marker='o',markersize=12,linewidth=2,color='orange',
-        label='Create Obsblocks (row)')
-    lines = l1+l2
+    l2 = ax2.plot(
+        df["Create_Obsblocks"],
+        df["N_rows"],
+        marker="o",
+        markersize=12,
+        linewidth=2,
+        color="orange",
+        label="Create Obsblocks (row)",
+    )
+    lines = l1 + l2
     labels = [l.get_label() for l in lines]
     axsecond = axindex
-    df = df.sort_values('N_chan')
-    axindex+=1
+    df = df.sort_values("N_chan")
+    axindex += 1
     axf[axindex].set_ylabel(r"$N_{chans}$")
-    axf[axindex].plot(df['Create_Obsblocks']/df['N_rows'],df['N_chan'],
-        marker='<',markersize=12,linewidth=2,label='Create Obsblocks per spectrum')
-    axindex+=1
-    axf[axindex].plot(df['Baseline_1']/df['N_rows'],df['N_chan'],
-        marker='>',markersize=12,linewidth=2,label='Baseline 1 per spectrum')
+    axf[axindex].plot(
+        df["Create_Obsblocks"] / df["N_rows"],
+        df["N_chan"],
+        marker="<",
+        markersize=12,
+        linewidth=2,
+        label="Create Obsblocks per spectrum",
+    )
+    axindex += 1
+    axf[axindex].plot(
+        df["Baseline_1"] / df["N_rows"],
+        df["N_chan"],
+        marker=">",
+        markersize=12,
+        linewidth=2,
+        label="Baseline 1 per spectrum",
+    )
     axf[axindex].set_ylabel(r"$N_{chans}$")
-    axf[axindex].plot(df['Baseline_2']/df['N_rows'],df['N_chan'],
-        marker='+',markersize=12,linewidth=2,label='Baseline 2 per spectrum')
+    axf[axindex].plot(
+        df["Baseline_2"] / df["N_rows"],
+        df["N_chan"],
+        marker="+",
+        markersize=12,
+        linewidth=2,
+        label="Baseline 2 per spectrum",
+    )
     axf[axindex].set_ylabel(r"$N_{chans}$")
-    axf[axindex].plot(df['Baseline_3']/df['N_rows'],df['N_chan'],
-        marker='o',markersize=12,linewidth=2,label='Baseline 3 per spectrum')
+    axf[axindex].plot(
+        df["Baseline_3"] / df["N_rows"],
+        df["N_chan"],
+        marker="o",
+        markersize=12,
+        linewidth=2,
+        label="Baseline 3 per spectrum",
+    )
     axf[axindex].set_ylabel(r"$N_{chans}$")
-    #axf[0].set_xlabel("Time (s)")
-    #axf[1].set_xlabel("Time (s)")
-    #axf[2].set_xlabel("Time (s)")
-#    ax[0].set_xlabel("Time (s)")
-    #axf[2].set_ylabel(r"$N_{chans}$")
-    #axf[3].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
-    #axf[4].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
-    #axf[5].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
-    ax2.ticklabel_format(axis='y',style='sci',useMathText=True,scilimits=(0,0))
-    axindex+=1
+    # axf[0].set_xlabel("Time (s)")
+    # axf[1].set_xlabel("Time (s)")
+    # axf[2].set_xlabel("Time (s)")
+    #    ax[0].set_xlabel("Time (s)")
+    # axf[2].set_ylabel(r"$N_{chans}$")
+    # axf[3].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
+    # axf[4].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
+    # axf[5].set_ylabel(r"$N_{chans} \times * N_{rows}$ (scaled)")
+    ax2.ticklabel_format(axis="y", style="sci", useMathText=True, scilimits=(0, 0))
+    axindex += 1
     for j in range(axindex):
         axf[j].set_xlabel("Elapsed Time (s)")
-        axf[j].ticklabel_format(axis='y',style='sci',useMathText=True,scilimits=(0,0))
+        axf[j].ticklabel_format(axis="y", style="sci", useMathText=True, scilimits=(0, 0))
         if j == axsecond:
-            axf[j].legend(lines,labels,loc="upper left")
+            axf[j].legend(lines, labels, loc="upper left")
         else:
             axf[j].legend(loc="upper left")
-        #j.set_xscale('log')
-        #j.set_yscale('log')
-    for j in range(axindex,len(axf)):
-        axf[j].axis('off')
-    plt.subplots_adjust(wspace=0.35,hspace=0.25)
-    fontdict = {'size':14,'fontweight':'bold'}
-    fig.suptitle(args.title,size=14,weight='bold')
+        # j.set_xscale('log')
+        # j.set_yscale('log')
+    for j in range(axindex, len(axf)):
+        axf[j].axis("off")
+    plt.subplots_adjust(wspace=0.35, hspace=0.25)
+    fig.suptitle(args.title, size=14, weight="bold")
     if args.outfile:
-        plt.savefig(args.outfile,dpi=300)
+        plt.savefig(args.outfile, dpi=300)
     plt.show()
-    
 
-def barplots(file,x_col='N_rows'):
+
+def barplots(file, x_col="N_rows"):
     plt.rcParams["xtick.major.size"] = 7
     plt.rcParams["xtick.minor.size"] = 4
     plt.rcParams["ytick.major.size"] = 7
     plt.rcParams["ytick.minor.size"] = 4
-    plt.rcParams['font.size'] = 22
-    plt.rcParams['axes.linewidth'] =1.5
-    t_python = Table.read(file[0],format='ipac')
-    t_idl    = Table.read(file[1],format='ipac')
-    colors =  ['#377eb8', '#ff7f00','#4daf4a',
-               '#f781bf', '#a65628', '#984ea3',
-               '#999999', '#e41a1c', '#dede00', '#595959',
-               '#5F9ED1', '#C85200', '#898989', 
-               '#A2C8EC', '#FFBC79', '#CFCFCF']
-
-    size_col = 'Size'
+    plt.rcParams["font.size"] = 22
+    plt.rcParams["axes.linewidth"] = 1.5
+    t_python = Table.read(file[0], format="ipac")
+    t_idl = Table.read(file[1], format="ipac")
+    colors = [
+        "#377eb8",
+        "#ff7f00",
+        "#4daf4a",
+        "#f781bf",
+        "#a65628",
+        "#984ea3",
+        "#999999",
+        "#e41a1c",
+        "#dede00",
+        "#595959",
+        "#5F9ED1",
+        "#C85200",
+        "#898989",
+        "#A2C8EC",
+        "#FFBC79",
+        "#CFCFCF",
+    ]
+
+    size_col = "Size"
     df = dict()
     df["p"] = t_python.to_pandas().sort_values(size_col)
     df["i"] = t_idl.to_pandas().sort_values(size_col)
-    time_cols = ['Load','Index', 'Create_Obsblocks' , 'Baseline_1','Baseline_2','Baseline_3']
-    tc = [ s.replace('_','\n') for s in time_cols ]
-    tc[2] = 'Create\nSpectra'
-    #df[time_cols] /= 1000.0
+    time_cols = ["Load", "Index", "Create_Obsblocks", "Baseline_1", "Baseline_2", "Baseline_3"]
+    tc = [s.replace("_", "\n") for s in time_cols]
+    tc[2] = "Create\nSpectra"
+    # df[time_cols] /= 1000.0
     for key in df:
         df[key][size_col] = np.rint(df[key][size_col]).astype(int)
         for j in time_cols:
-            df[key][j] = df[key][j]/df[key]['N_rows']
+            df[key][j] = df[key][j] / df[key]["N_rows"]
 
-    fig,ax = plt.subplots(figsize=(12,10))
-   # print("TIME ",list(df["p"][time_cols].mean()))
-   # print(df["p"])
+    fig, ax = plt.subplots(figsize=(12, 10))
+    # print("TIME ",list(df["p"][time_cols].mean()))
+    # print(df["p"])
     ind = np.arange(len(time_cols))
     width = 0.2
-    ax.bar(ind,list(df["p"][time_cols].mean()),width,log=args.logy,label="dysh prototype",color=colors[6])
-    ax.bar(ind+width,list(df["i"][time_cols].mean()),width,log=args.logy,label="GBTIDL",color=colors[4])
-    ax.set_xticks(ind+width,labels=tc)
-    ax.set_ylabel("Operation Time per spectrum (ms)",fontweight="demibold",labelpad=6)
-    ax.set_xlabel("Operation",fontweight="demibold",labelpad=6)
+    ax.bar(ind, list(df["p"][time_cols].mean()), width, log=args.logy, label="dysh prototype", color=colors[6])
+    ax.bar(ind + width, list(df["i"][time_cols].mean()), width, log=args.logy, label="GBTIDL", color=colors[4])
+    ax.set_xticks(ind + width, labels=tc)
+    ax.set_ylabel("Operation Time per spectrum (ms)", fontweight="demibold", labelpad=6)
+    ax.set_xlabel("Operation", fontweight="demibold", labelpad=6)
     pure_numpy = 2.5
-    pure_numpy = { 0: 0.0, 1: 0, 2:0, 3:3.6, 4:7.2, 5:10.86}
-    ax.bar(ind+2*width,list(pure_numpy.values()),width,log=args.logy,label="pure numpy",color=colors[0])
+    pure_numpy = {0: 0.0, 1: 0, 2: 0, 3: 3.6, 4: 7.2, 5: 10.86}
+    ax.bar(ind + 2 * width, list(pure_numpy.values()), width, log=args.logy, label="pure numpy", color=colors[0])
     # from peter
-    pure_c = { 0: 0.6, 1: 0, 2:0, 3:0.58, 4:0.81, 5:1.16}
-    pure_c = { 0: 0.0, 1: 0, 2:0, 3:0.58, 4:0.81, 5:1.16}
+    pure_c = {0: 0.6, 1: 0, 2: 0, 3: 0.58, 4: 0.81, 5: 1.16}
+    pure_c = {0: 0.0, 1: 0, 2: 0, 3: 0.58, 4: 0.81, 5: 1.16}
     # take 0.75 because peter did the whole spectrum
-    ax.bar(ind+3*width,0.75*np.array(list(pure_c.values())),width,log=args.logy,label="pure C",color=colors[8])
-    
-    #ax.hlines(pure_numpy,2.75,4.,lw=3,color=colors[0],label="pure numpy")
+    ax.bar(
+        ind + 3 * width, 0.75 * np.array(list(pure_c.values())), width, log=args.logy, label="pure C", color=colors[8]
+    )
+
+    # ax.hlines(pure_numpy,2.75,4.,lw=3,color=colors[0],label="pure numpy")
     handles, labels = ax.get_legend_handles_labels()
-    #print(handles)
-    #print(sorted(labels))
+    # print(handles)
+    # print(sorted(labels))
     # sort both labels and handles by labels
-    #print(sorted(zip(labels,handles),key=lambda t: t[0].lower()))
-    #labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
-#    ax.legend([handles[1],handles[2],handles[3],handles[0]], [labels[1],labels[2],labels[3],labels[0]])
+    # print(sorted(zip(labels,handles),key=lambda t: t[0].lower()))
+    # labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))
+    #    ax.legend([handles[1],handles[2],handles[3],handles[0]], [labels[1],labels[2],labels[3],labels[0]])
     ax.legend()
-    ax.set_title(args.title,weight='bold')
+    ax.set_title(args.title, weight="bold")
     plt.tight_layout()
     if args.show:
         plt.show()
     if args.outfile:
-        plt.savefig(args.outfile,dpi=150)
-#--------------------------------------------
-    #ax = df["p"].plot.bar(x=size_col, y=time_cols,
-    #        stacked=False, logy=False, 
-    #        xlabel='File Size', ylabel = 'Time per spectrum (ms)',rot=0)#figsize=(15,12),rot=0)
-    #fig = ax.get_figure()
-    #ax2 = df["i"].plot.bar(x=size_col, y=time_cols,
-    #        stacked=False, logy=False, ax=ax,rot=0)#figsize=(15,12),rot=0)
+        plt.savefig(args.outfile, dpi=150)
+
+
+# --------------------------------------------
+# ax = df["p"].plot.bar(x=size_col, y=time_cols,
+#        stacked=False, logy=False,
+#        xlabel='File Size', ylabel = 'Time per spectrum (ms)',rot=0)#figsize=(15,12),rot=0)
+# fig = ax.get_figure()
+# ax2 = df["i"].plot.bar(x=size_col, y=time_cols,
+#        stacked=False, logy=False, ax=ax,rot=0)#figsize=(15,12),rot=0)
 #    print(ax.containers)
 #    ax.bar_label(ax.containers[2],labels=df[size_col],backgroundcolor='blue',color='white',padding=-30)
 #    ax.bar_label(ax.containers[2],labels=df['N_chan'],backgroundcolor='gray',color='white',padding=-50)
@@ -179,47 +224,48 @@ def barplots(file,x_col='N_rows'):
 #    #legend = add_patch(legend,fc='blue',label='File Size (MB)')
 #    legend = add_patch(legend,fc=['blue','gray'],
 #             label=['File Size (MB)','# Channels'])
-    #ax.set_title("Timing for SDFITSLoad operations")
+# ax.set_title("Timing for SDFITSLoad operations")
 
-    #plt.savefig("sdfitsload_timing.png",dpi=300)
+# plt.savefig("sdfitsload_timing.png",dpi=300)
 #    ax = df.plot.bar(x=x_col, y=time_cols[0:2],
-#            stacked=False, logy=False, 
+#            stacked=False, logy=False,
 #            xlabel='Number of Rows', ylabel = 'Time (s)',rot=0)#figsize=(15,12),rot=0)
 #    ax.bar_label(ax.containers[-1],labels=df[size_col],backgroundcolor='blue',color='white')
 #    ax.bar_label(ax.containers[-1],labels=df['N_chan'],backgroundcolor='gray',color='white',padding=20)
 #    legend = ax.get_legend()
-    #legend = add_patch(legend,fc='blue',label='File Size (MB)')
+# legend = add_patch(legend,fc='blue',label='File Size (MB)')
 #    legend = add_patch(legend,fc=['blue','gray'],
 #             label=['File Size (MB)','# Channels'])
 #    #plt.subplot_tool(targetfig=fig)
-    #plt.savefig("sdfitsload_timing_short.png",dpi=300)
+# plt.savefig("sdfitsload_timing_short.png",dpi=300)
 
-#ax.tick_params(axis='x',rotation=0)
-#ax.xaxis.set_major_formatter(FormatStrFormatter("%.1f"))
+# ax.tick_params(axis='x',rotation=0)
+# ax.xaxis.set_major_formatter(FormatStrFormatter("%.1f"))
 
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(prog="revisedstructure")
-    parser.add_argument('--file','-f', action='store', help='input filename')
-    parser.add_argument('--file2','-g', action='store', help='2nd input filename [gbtidl], barplots only')
-    parser.add_argument('--barplots','-b', action='store_true', help='show barplots',default=False)
-    parser.add_argument('--lineplots','-l', action='store_true', help='show lineplots',default=False)
-    parser.add_argument('--title','-t', action='store', help='Plot title',default="Timing for Load/Obsblocks/Baseline")
-    parser.add_argument('--outfile','-o', action='store', help='output file',default=None)
-    parser.add_argument('--logy', action='store_true', help='log y axis',default=False)
-    parser.add_argument('--logx', action='store_true', help='log x axis',default=False)
-    parser.add_argument('--show', action='store_true', help='show plot',default=False)
+    parser.add_argument("--file", "-f", action="store", help="input filename")
+    parser.add_argument("--file2", "-g", action="store", help="2nd input filename [gbtidl], barplots only")
+    parser.add_argument("--barplots", "-b", action="store_true", help="show barplots", default=False)
+    parser.add_argument("--lineplots", "-l", action="store_true", help="show lineplots", default=False)
+    parser.add_argument(
+        "--title", "-t", action="store", help="Plot title", default="Timing for Load/Obsblocks/Baseline"
+    )
+    parser.add_argument("--outfile", "-o", action="store", help="output file", default=None)
+    parser.add_argument("--logy", action="store_true", help="log y axis", default=False)
+    parser.add_argument("--logx", action="store_true", help="log x axis", default=False)
+    parser.add_argument("--show", action="store_true", help="show plot", default=False)
     args = parser.parse_args()
-    print("ARGS ",args)
+    print("ARGS ", args)
     if args.lineplots:
         lineplots(file=args.file)
     if args.barplots:
-        barplots(file=[args.file,args.file2])
+        barplots(file=[args.file, args.file2])
 if False:
     for c in ax.containers:
-
         # Optional: if the segment is small or 0, customize the labels
-        labels = [np.rint(v.get_height()).astype(int) if v.get_height() > 0 else '' for v in c]
+        labels = [np.rint(v.get_height()).astype(int) if v.get_height() > 0 else "" for v in c]
 
         # remove the labels parameter if it's not needed for customized labels
-        ax.bar_label(c, labels=labels, label_type='center')
+        ax.bar_label(c, labels=labels, label_type="center")
diff --git a/benchmark/revisedstructure.py b/benchmark/revisedstructure.py
index d5545827..ad410bd5 100755
--- a/benchmark/revisedstructure.py
+++ b/benchmark/revisedstructure.py
@@ -1,41 +1,43 @@
-#!/usr/bin/env python 
-from dysh.sdfitsload import SDFITSLoad, get_size, Obsblock,baseline
+#!/usr/bin/env python
+import argparse
+import cProfile
 import os
+import pstats
 import sys
 import time
-import cProfile
-import pstats
 from pstats import SortKey
+
 import numpy as np
-from astropy.table import Table,vstack
-from specutils import Spectrum1D, SpectrumList,SpectralRegion
-import argparse
+from astropy.table import Table, vstack
+from dysh.sdfitsload import SDFITSLoad, baseline
+from specutils import SpectralRegion
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(prog="revisedstructure")
-    parser.add_argument('--file','-f', action='store', help='input filename', required=True)
-    parser.add_argument('--wcs',action='store_true', help='create WCS for each Spectrum1D')
-    parser.add_argument('--fix',action='store_true', help='fix warnings about keywords in WCS creation')
-    parser.add_argument('--profile', '-p',  action='store_true', help='run the profiler')
-    parser.add_argument('--baseline','-b', action='store_true', help='remove baselines')
-    parser.add_argument('--obsblocks','-o', action='store_true', help='create obsblocks')
-    parser.add_argument('--index','-i', action='store_true', help='create index table (pandas)')
-    parser.add_argument('--maxload','-m', action='store', help='maximum number of spectra to load (create obsblocks)',default=1E16)
-#    parser.add_argument('--baseline','-b', action='store', help='remove baselines',default=None)
+    parser.add_argument("--file", "-f", action="store", help="input filename", required=True)
+    parser.add_argument("--wcs", action="store_true", help="create WCS for each Spectrum1D")
+    parser.add_argument("--fix", action="store_true", help="fix warnings about keywords in WCS creation")
+    parser.add_argument("--profile", "-p", action="store_true", help="run the profiler")
+    parser.add_argument("--baseline", "-b", action="store_true", help="remove baselines")
+    parser.add_argument("--obsblocks", "-o", action="store_true", help="create obsblocks")
+    parser.add_argument("--index", "-i", action="store_true", help="create index table (pandas)")
+    parser.add_argument(
+        "--maxload", "-m", action="store", help="maximum number of spectra to load (create obsblocks)", default=1e16
+    )
+    #    parser.add_argument('--baseline','-b', action='store', help='remove baselines',default=None)
     args = parser.parse_args()
     print(f"using {args}")
 
     examples = "/data/gbt/examples/"
     files = [
-    #"rxco-W/data/TSCAL_220105_W.raw.vegas/TSCAL_220105_W.raw.vegas.E.fits",
-    #"onoff-L/data/TGBT21A_501_11.raw.vegas.fits", 
-    #"nod-KFPA/data/TGBT22A_503_02.raw.vegas/TGBT22A_503_02.raw.vegas.F.fits",
-    "misc/ngc5291.fits",
-    #"misc/W3OH.fits",
-    #"misc/IC1481.fits",
-    #"mapping-L/data/TGBT17A_506_11.raw.vegas/TGBT17A_506_11.raw.vegas.A.fits", 
-    #"mixed-fs-ps/data/AGBT16B_225_05/AGBT16B_225_05.raw.vegas/AGBT16B_225_05.raw.vegas.B.fits",
-
+        # "rxco-W/data/TSCAL_220105_W.raw.vegas/TSCAL_220105_W.raw.vegas.E.fits",
+        # "onoff-L/data/TGBT21A_501_11.raw.vegas.fits",
+        # "nod-KFPA/data/TGBT22A_503_02.raw.vegas/TGBT22A_503_02.raw.vegas.F.fits",
+        "misc/ngc5291.fits",
+        # "misc/W3OH.fits",
+        # "misc/IC1481.fits",
+        # "mapping-L/data/TGBT17A_506_11.raw.vegas/TGBT17A_506_11.raw.vegas.A.fits",
+        # "mixed-fs-ps/data/AGBT16B_225_05/AGBT16B_225_05.raw.vegas/AGBT16B_225_05.raw.vegas.B.fits",
     ]
     timestr = ""
     files = [args.file]
@@ -55,85 +57,96 @@
     tb3 = np.zeros(len(files))
     t5 = np.zeros(len(files))
     hdu = np.zeros(len(files))
-    i=0
-    names =['File', 'Size','N_hdu','HDU','N_rows','N_chan', 'Load','Index', 'Create_Obsblocks','Baseline_1', 'Baseline_2', 'Baseline_3', 'Total']
-    units = ['',     'MB',   '',    '',    '',      '' ,    'ms',   'ms',      'ms',             'ms',            'ms'      ,   'ms',       'ms' ]
-    dtypes = [str, float,   int,    int,  int,    int,      float,  float,    float,            float,          float,         float,      float]
-    table = Table( names=names, meta={'name':'SDFITSLoad Timing'},
-                   units=units,dtype=dtypes)
+    i = 0
+    names = [
+        "File",
+        "Size",
+        "N_hdu",
+        "HDU",
+        "N_rows",
+        "N_chan",
+        "Load",
+        "Index",
+        "Create_Obsblocks",
+        "Baseline_1",
+        "Baseline_2",
+        "Baseline_3",
+        "Total",
+    ]
+    units = ["", "MB", "", "", "", "", "ms", "ms", "ms", "ms", "ms", "ms", "ms"]
+    dtypes = [str, float, int, int, int, int, float, float, float, float, float, float, float]
+    table = Table(names=names, meta={"name": "SDFITSLoad Timing"}, units=units, dtype=dtypes)
     for fn in files:
         basename = os.path.basename(fn)
         pr = cProfile.Profile()
-        inf = f'{examples}{fn}'
-        size[i] = os.path.getsize(fn)/1048576
+        inf = f"{examples}{fn}"
+        size[i] = os.path.getsize(fn) / 1048576
         t0[i] = time.perf_counter_ns()
         pr.enable()
-        s = SDFITSLoad(fn,index=False)
+        s = SDFITSLoad(fn, index=False)
         t0a[i] = time.perf_counter_ns()
         if args.index:
-            for h in range(1,len(s._hdu)):
+            for h in range(1, len(s._hdu)):
                 t1p[i] = time.perf_counter_ns()
                 s.load_pandas(hdu=h)
                 t2p[i] = time.perf_counter_ns()
-        for h in range(1,len(s._hdu)):
+        for h in range(1, len(s._hdu)):
             hdu[i] = h
             if args.obsblocks:
                 t1[i] = time.perf_counter_ns()
-                s._loadlists(fix=args.fix,wcs=args.wcs,hdu=int(hdu),maxspect=float(args.maxload))
+                s._loadlists(fix=args.fix, wcs=args.wcs, hdu=int(hdu), maxspect=float(args.maxload))
                 t2[i] = time.perf_counter_ns()
                 nchanl[i] = len(s._obsblock[0][0].spectral_axis)
-            if args.baseline:# is not None:
-                j=0
+            if args.baseline:  # is not None:
+                j = 0
                 for o in s._obsblock:
                     p = o[0]
                     x = o[0].spectral_axis
                     nchan = len(x)
-                    cdelt = x[1]-x[0]
+                    cdelt = x[1] - x[0]
                     center = x[nchan // 2]
-                    width = 0.25*nchan*cdelt
-                    exclude = SpectralRegion.from_center(center,width)
-                    print("EXCLUDE ",exclude,file=sys.stderr)
-                    baseline(speclist=o,order=1,exclude=exclude,maxspec=1000)
+                    width = 0.25 * nchan * cdelt
+                    exclude = SpectralRegion.from_center(center, width)
+                    print("EXCLUDE ", exclude, file=sys.stderr)
+                    baseline(speclist=o, order=1, exclude=exclude, maxspec=1000)
                     tb1[i] = time.perf_counter_ns()
-                    print("Done O1",file=sys.stderr)
-                    baseline(speclist=o,order=2,exclude=exclude,maxspec=1000)
+                    print("Done O1", file=sys.stderr)
+                    baseline(speclist=o, order=2, exclude=exclude, maxspec=1000)
                     tb2[i] = time.perf_counter_ns()
-                    print("Done O2",file=sys.stderr)
-                    baseline(speclist=o,order=3,exclude=exclude,maxspec=1000)
+                    print("Done O2", file=sys.stderr)
+                    baseline(speclist=o, order=3, exclude=exclude, maxspec=1000)
                     tb3[i] = time.perf_counter_ns()
-                    print("Done O3",file=sys.stderr)
-                    j=j+1
+                    print("Done O3", file=sys.stderr)
+                    j = j + 1
             t3[i] = time.perf_counter_ns()
             pr.disable()
-            #s.summary()
-            nhdu[i] = len(s._hdu)-1
-            nrows[i] = s.nrows(h-1)
-            load = (t0a-t0)/1E6
-            index = (t2p-t1p)/1E6
-            obs  = (t2-t1)/1E6
-            base1  = (tb1-t2)/1E6
-            base2  = (tb2-tb1)/1E6
-            base3  = (tb3-tb2)/1E6
-            total = (t3-t0)/1E6
-            table.add_row([basename,size,nhdu,hdu,nrows,nchanl,load,index,obs,base1,base2,base3,total])
+            # s.summary()
+            nhdu[i] = len(s._hdu) - 1
+            nrows[i] = s.nrows(h - 1)
+            load = (t0a - t0) / 1e6
+            index = (t2p - t1p) / 1e6
+            obs = (t2 - t1) / 1e6
+            base1 = (tb1 - t2) / 1e6
+            base2 = (tb2 - tb1) / 1e6
+            base3 = (tb3 - tb2) / 1e6
+            total = (t3 - t0) / 1e6
+            table.add_row([basename, size, nhdu, hdu, nrows, nchanl, load, index, obs, base1, base2, base3, total])
         del s
 
-        #s = io.StringIO()
-        #sortby = (SortKey.TIME,SortKey.CUMULATIVE)
+        # s = io.StringIO()
+        # sortby = (SortKey.TIME,SortKey.CUMULATIVE)
         ps = pstats.Stats(pr).sort_stats(SortKey.CUMULATIVE)
         ps.print_stats(25)
-        i+=1
-
+        i += 1
 
     for c in table.columns:
         if table[c].info.dtype == float:
-            table[c].info.format = '0.1f'
+            table[c].info.format = "0.1f"
 
     if os.path.exists("tab.out"):
-        oldtable = Table.read("tab.out",format='ipac')
-        table2 = vstack([oldtable,table])
+        oldtable = Table.read("tab.out", format="ipac")
+        table2 = vstack([oldtable, table])
     else:
         table2 = table
-    table2.write("tab.out",format='ipac',overwrite=True)
-    #t2.pprint_all()
-
+    table2.write("tab.out", format="ipac", overwrite=True)
+    # t2.pprint_all()
diff --git a/benchmark/stats-wcs-meta.2022-03-31-OMP=1 b/benchmark/stats-wcs-meta.2022-03-31-OMP=1
index bf6c4957..a9d18ee9 100644
--- a/benchmark/stats-wcs-meta.2022-03-31-OMP=1
+++ b/benchmark/stats-wcs-meta.2022-03-31-OMP=1
@@ -348,5 +348,3 @@ NUMBER OF BAD SPECTRA: 1680
     92032    0.494    0.000 2204.274    0.024 /n/lupus/mpound/anaconda3/lib/python3.9/site-packages/gwcs/api.py:94(pixel_to_world_values)
     92032    0.613    0.000 2194.394    0.024 /n/lupus/mpound/anaconda3/lib/python3.9/site-packages/gwcs/wcs.py:332(__call__)
 26651872454 2078.207    0.000 2078.207    0.000 {built-in method numpy.asanyarray}
-
-
diff --git a/benchmark/stats-wcs-meta.2022-04-02-OMPunset b/benchmark/stats-wcs-meta.2022-04-02-OMPunset
index bb96e509..09aa7a0c 100644
--- a/benchmark/stats-wcs-meta.2022-04-02-OMPunset
+++ b/benchmark/stats-wcs-meta.2022-04-02-OMPunset
@@ -348,5 +348,3 @@ NUMBER OF BAD SPECTRA: 1680
     92032    0.477    0.000 2174.092    0.024 /n/lupus/mpound/anaconda3/lib/python3.9/site-packages/gwcs/api.py:94(pixel_to_world_values)
     92032    0.579    0.000 2164.603    0.024 /n/lupus/mpound/anaconda3/lib/python3.9/site-packages/gwcs/wcs.py:332(__call__)
 26651872454 2053.948    0.000 2053.948    0.000 {built-in method numpy.asanyarray}
-
-
diff --git a/benchmark/tab.out b/benchmark/tab.out
index 7a3ba37a..7b5d03f7 100644
--- a/benchmark/tab.out
+++ b/benchmark/tab.out
@@ -2,6 +2,5 @@
 |                           char|double| long|long|  long|  long|double|double|          double|    double|    double|    double|  double|
 |                               | Mbyte|     |    |      |      |    ms|    ms|              ms|        ms|        ms|        ms|      ms|
 |                           null|  null| null|null|  null|  null|  null|  null|            null|      null|      null|      null|    null|
- TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  124.8  205.7           3667.5    66850.2    67657.7    80611.8 219117.9 
- TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  105.3  178.3           2998.0     3288.5     4479.3     3885.1 14934.6 
-
+ TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  124.8  205.7           3667.5    66850.2    67657.7    80611.8 219117.9
+ TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  105.3  178.3           2998.0     3288.5     4479.3     3885.1 14934.6
diff --git a/benchmark/tab_gbtidl.out b/benchmark/tab_gbtidl.out
index 594dfc03..eda5940a 100644
--- a/benchmark/tab_gbtidl.out
+++ b/benchmark/tab_gbtidl.out
@@ -2,7 +2,7 @@
 |                           char| double| long|long|  long|  long|double| double|          double|    double|    double|    double|      double|
 |                               |  Mbyte|     |    |      |      |    ms|     ms|              ms|        ms|        ms|        ms|          ms|
 |                           null|   null| null|null|  null|  null|  null|   null|            null|      null|      null|      null|        null|
- TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024 580.90  711.26          20872.4    381.964    539.131    695.831      23781.5   
-   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768 6531.3 5005.89          95003.6    19253.0    30997.4    42464.0     199255.0 
+ TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024 580.90  711.26          20872.4    381.964    539.131    695.831      23781.5
+   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768 6531.3 5005.89          95003.6    19253.0    30997.4    42464.0     199255.0
  TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    1  32760  32768 32776. 27701.8      1.14723e+06    139197.    230783.    321342.  1.89903e+06
  TGBT22A_503_02.raw.vegas.F.fits  2369.3     1    1  18864  32768 26663. 24011.3          670952.    138626.    231440.    324118.  1.41581e+06
diff --git a/benchmark/tab_newton.out b/benchmark/tab_newton.out
index 2669b863..ff0af00d 100644
--- a/benchmark/tab_newton.out
+++ b/benchmark/tab_newton.out
@@ -2,8 +2,8 @@
 |                         char    |double| long|long|  long|  long|double|double |          double|    double|    double|    double|   double |
 |                                 | Mbyte|     |    |      |      |    ms|    ms |              ms|        ms|        ms|        ms|       ms |
 |                         null    |  null| null|null|  null|  null|  null|  null |            null|      null|      null|      null|     null |
-                   IC1481.fits       16.2     1    1    512   8192  177.0  178.9            4421.8    57833.0    61867.8    73540.0   198018.6  
-                     W3OH.fits       30.2     1    1    480  16384  171.4  188.5            6152.6   132448.9   134729.0   154549.9   428240.3 
-                  ngc5291.fits       44.1     1    1    352  32768  170.4  203.0            7693.4   199499.7   195887.2   196708.8   600162.6 
- TGBT21A_501_11.raw.vegas.fits      758.6     1    1   6040  32768  246.4 8242.2          126248.1  1692866.0  1712327.7  1742733.0  5282663.5 
- TGBT22A_503_02.raw.vegas.F.fits   2369.3     1    1  18864  32768  247.8 26737.3         373916.9 5438939.2   5551911.8  5537855.9 16929609.1 
+                   IC1481.fits       16.2     1    1    512   8192  177.0  178.9            4421.8    57833.0    61867.8    73540.0   198018.6
+                     W3OH.fits       30.2     1    1    480  16384  171.4  188.5            6152.6   132448.9   134729.0   154549.9   428240.3
+                  ngc5291.fits       44.1     1    1    352  32768  170.4  203.0            7693.4   199499.7   195887.2   196708.8   600162.6
+ TGBT21A_501_11.raw.vegas.fits      758.6     1    1   6040  32768  246.4 8242.2          126248.1  1692866.0  1712327.7  1742733.0  5282663.5
+ TGBT22A_503_02.raw.vegas.F.fits   2369.3     1    1  18864  32768  247.8 26737.3         373916.9 5438939.2   5551911.8  5537855.9 16929609.1
diff --git a/benchmark/tab_newton_linearlsq.out b/benchmark/tab_newton_linearlsq.out
index 0b0d3674..bdea38e7 100644
--- a/benchmark/tab_newton_linearlsq.out
+++ b/benchmark/tab_newton_linearlsq.out
@@ -2,9 +2,9 @@
 |                           char|double| long|long|  long|  long|double|double|          double|    double|    double|    double|   double|
 |                               | Mbyte|     |    |      |      |    ms|    ms|              ms|        ms|        ms|        ms|       ms|
 |                           null|  null| null|null|  null|  null|  null|  null|            null|      null|      null|      null|     null|
- TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  173.4  303.8           4516.4     4564.3     5389.0     5220.1   20167.0 
-                     IC1481.fits   16.2     1    1    512   8192  173.5  180.5           4445.9     3840.8     2995.4     3478.0   15114.2 
-                       W3OH.fits   30.2     1    1    480  16384  169.9  195.2           6063.8     4804.2     3116.3     3614.2   17963.8 
-                    ngc5291.fits   44.1     1    1    352  32768  170.6  204.1           7010.6     5443.4     2716.5     3213.6   18758.9 
-   TGBT21A_501_11.raw.vegas.fits  758.6     1    1   6040  32768  175.4 1278.2         129796.0    90870.0    47973.4    57034.9  327127.9 
- TGBT22A_503_02.raw.vegas.F.fits 2369.3     1    1  18864  32768  171.7 3542.6         376636.5   288639.3   157153.2   186018.7 1012162.1 
+ TSCAL_220105_W.raw.vegas.E.fits    3.9     1    1    864   1024  173.4  303.8           4516.4     4564.3     5389.0     5220.1   20167.0
+                     IC1481.fits   16.2     1    1    512   8192  173.5  180.5           4445.9     3840.8     2995.4     3478.0   15114.2
+                       W3OH.fits   30.2     1    1    480  16384  169.9  195.2           6063.8     4804.2     3116.3     3614.2   17963.8
+                    ngc5291.fits   44.1     1    1    352  32768  170.6  204.1           7010.6     5443.4     2716.5     3213.6   18758.9
+   TGBT21A_501_11.raw.vegas.fits  758.6     1    1   6040  32768  175.4 1278.2         129796.0    90870.0    47973.4    57034.9  327127.9
+ TGBT22A_503_02.raw.vegas.F.fits 2369.3     1    1  18864  32768  171.7 3542.6         376636.5   288639.3   157153.2   186018.7 1012162.1
diff --git a/benchmark/tab_omp=1.out b/benchmark/tab_omp=1.out
index f6cd07ee..2b6b7ea3 100644
--- a/benchmark/tab_omp=1.out
+++ b/benchmark/tab_omp=1.out
@@ -2,12 +2,12 @@
 |                           char| double| long|long|  long|  long|double| double|          double|    double|    double|    double|    double|
 |                               |  Mbyte|     |    |      |      |    ms|     ms|              ms|        ms|        ms|        ms|        ms|
 |                           null|   null| null|null|  null|  null|  null|   null|            null|      null|      null|      null|      null|
- TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024  100.7   172.3           2263.0    49396.7    52168.2    56323.5   161112.6 
-                     IC1481.fits    16.2     1    1    512   8192  108.6   137.5           2705.4    28665.6    30532.1    36316.7    99131.0 
-                       W3OH.fits    30.2     1    1    480  16384  109.6   171.4           3867.8    65098.4    66128.8    75229.8   210715.1 
-                    ngc5291.fits    44.1     1    1    352  32768  104.1   166.9           4859.0    93757.3    94422.4    95640.6   289102.6 
-   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768  111.1  1858.9          83792.5   824151.0   832254.8   847553.3  2589849.0 
- TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    1  15680  32768  105.9  1081.4         219250.4  2133169.5  2172395.8  2222978.8  6754146.9 
- TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    2  17080  32768  105.9  1081.4         208179.1  1527539.4  1515398.1  1492196.0 11497460.9 
- TGBT22A_503_02.raw.vegas.F.fits  2369.3     1    1  18864  32768  114.7  5100.8         260934.7  2561723.5  2593644.0  2628196.9  8050981.9 
- AGBT16B_225_05.raw.vegas.B.fits 23063.0     1    1  92032  65536  113.9 47308.9        2387830.2 24877229.4 25748085.3 27065582.8 80135424.5 
+ TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024  100.7   172.3           2263.0    49396.7    52168.2    56323.5   161112.6
+                     IC1481.fits    16.2     1    1    512   8192  108.6   137.5           2705.4    28665.6    30532.1    36316.7    99131.0
+                       W3OH.fits    30.2     1    1    480  16384  109.6   171.4           3867.8    65098.4    66128.8    75229.8   210715.1
+                    ngc5291.fits    44.1     1    1    352  32768  104.1   166.9           4859.0    93757.3    94422.4    95640.6   289102.6
+   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768  111.1  1858.9          83792.5   824151.0   832254.8   847553.3  2589849.0
+ TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    1  15680  32768  105.9  1081.4         219250.4  2133169.5  2172395.8  2222978.8  6754146.9
+ TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    2  17080  32768  105.9  1081.4         208179.1  1527539.4  1515398.1  1492196.0 11497460.9
+ TGBT22A_503_02.raw.vegas.F.fits  2369.3     1    1  18864  32768  114.7  5100.8         260934.7  2561723.5  2593644.0  2628196.9  8050981.9
+ AGBT16B_225_05.raw.vegas.B.fits 23063.0     1    1  92032  65536  113.9 47308.9        2387830.2 24877229.4 25748085.3 27065582.8 80135424.5
diff --git a/benchmark/tab_omp_unset.out b/benchmark/tab_omp_unset.out
index 7d169734..d4c852e6 100644
--- a/benchmark/tab_omp_unset.out
+++ b/benchmark/tab_omp_unset.out
@@ -2,12 +2,12 @@
 |                           char| double| long|long|  long|  long|double| double|          double|    double|    double|    double|    double|
 |                               |  Mbyte|     |    |      |      |    ms|     ms|              ms|        ms|        ms|        ms|        ms|
 |                           null|   null| null|null|  null|  null|  null|   null|            null|      null|      null|      null|      null|
- TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024   77.8   143.4           2262.6    49575.1    52034.8    56305.8   160677.2 
-                     IC1481.fits    16.2     1    1    512   8192  103.7   134.8           2700.7    29500.9    31387.3    37319.1   101748.7 
-                       W3OH.fits    30.2     1    1    480  16384  111.3   146.6           3793.0    65063.6    66036.1    74831.0   210114.8 
-                    ngc5291.fits    44.1     1    1    352  32768  100.2   187.1           4876.4    94007.3    93984.9    94573.9   287873.0 
-   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768  108.4  1416.1          83511.8   820156.9   831134.3   843179.2  2580121.8 
- TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    1  15680  32768  130.9  1090.2         219594.3  2116072.3  2149663.4  2201968.1  6693722.2 
- TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    2  17080  32768  130.9  1090.2         209911.4  1480862.7  1473921.8  1461401.1 11319821.3 
- TGBT22A_503_02.raw.vegas.F.fits  2369.3     1    1  18864  32768  100.7  5106.9         261744.6  2525333.0  2546693.4  2600808.0  7939946.2 
- AGBT16B_225_05.raw.vegas.B.fits 23063.0     1    1  92032  65536  122.8 47289.5        2357476.8 25082014.3 25818002.8 26883175.4 80188194.4 
+ TSCAL_220105_W.raw.vegas.E.fits     3.9     1    1    864   1024   77.8   143.4           2262.6    49575.1    52034.8    56305.8   160677.2
+                     IC1481.fits    16.2     1    1    512   8192  103.7   134.8           2700.7    29500.9    31387.3    37319.1   101748.7
+                       W3OH.fits    30.2     1    1    480  16384  111.3   146.6           3793.0    65063.6    66036.1    74831.0   210114.8
+                    ngc5291.fits    44.1     1    1    352  32768  100.2   187.1           4876.4    94007.3    93984.9    94573.9   287873.0
+   TGBT21A_501_11.raw.vegas.fits   758.6     1    1   6040  32768  108.4  1416.1          83511.8   820156.9   831134.3   843179.2  2580121.8
+ TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    1  15680  32768  130.9  1090.2         219594.3  2116072.3  2149663.4  2201968.1  6693722.2
+ TGBT17A_506_11.raw.vegas.A.fits  2246.5     2    2  17080  32768  130.9  1090.2         209911.4  1480862.7  1473921.8  1461401.1 11319821.3
+ TGBT22A_503_02.raw.vegas.F.fits  2369.3     1    1  18864  32768  100.7  5106.9         261744.6  2525333.0  2546693.4  2600808.0  7939946.2
+ AGBT16B_225_05.raw.vegas.B.fits 23063.0     1    1  92032  65536  122.8 47289.5        2357476.8 25082014.3 25818002.8 26883175.4 80188194.4
diff --git a/configure b/configure
index afa2898e..a541a855 100755
--- a/configure
+++ b/configure
@@ -2919,5 +2919,3 @@ if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
 printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
 fi
-
-
diff --git a/configure.ac b/configure.ac
index 74678327..b1669941 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-dnl Process this file with autoconf to produce a new configure script if it has changed. 
+dnl Process this file with autoconf to produce a new configure script if it has changed.
 dnl ------------------------------------------------------------------------------------
 
 AC_INIT
diff --git a/docs/conf.py b/docs/conf.py
index 130d5139..52b6a92d 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -14,13 +14,13 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('..'))
-sys.path.insert(0, os.path.abspath('../src'))
-sys.path.insert(0, os.path.abspath('../src/dysh'))
-#sys.path.insert(0, os.path.abspath('../src'))
+
+sys.path.insert(0, os.path.abspath(".."))
+sys.path.insert(0, os.path.abspath("../src"))
+sys.path.insert(0, os.path.abspath("../src/dysh"))
+# sys.path.insert(0, os.path.abspath('../src'))
 # sys.path.insert(0, os.path.abspath('.'))
 
-import dysh
 # -- Project information -----------------------------------------------------
 
 from dysh import __version__
@@ -58,7 +58,7 @@
     "sphinx.ext.viewcode",
     "sphinxcontrib.mermaid",
     "numpydoc",
-#    "sphinx_automodapi.automodapi",
+    #    "sphinx_automodapi.automodapi",
 ]
 
 numpydoc_show_class_members = True
@@ -76,12 +76,12 @@
 # The suffix(es) of source filenames.
 # You can specify multiple suffix as a list of string:
 #
-source_suffix = ['.rst', '.md']
-#source_suffix = {
+source_suffix = [".rst", ".md"]
+# source_suffix = {
 #    '.rst': 'restructuredtext',
 #    '.txt': 'markdown',
 #    '.md': 'markdown',
-#}
+# }
 
 # The master toctree document.
 master_doc = "index"
@@ -165,7 +165,7 @@
         master_doc,
         "dysh.tex",
         "dysh Documentation",
-        ["Marc Pound","Victoria Catlett", "Peter Teuben"],
+        ["Marc Pound", "Victoria Catlett", "Peter Teuben"],
         "manual",
     )
 ]
@@ -198,7 +198,7 @@
 # The reST default role (used for this markup: `text`) to use for all
 # documents. Set to the "smart" one.
 # This lets e.g, `~astropy.Foo` link without using :class:
-default_role = 'obj'
+default_role = "obj"
 
 # -- Extension configuration -------------------------------------------------
 
@@ -206,24 +206,24 @@
 
 # Example configuration for intersphinx: refer to the Python standard library.
 # intersphinx_mapping = {"https://docs.python.org/": None}
-intersphinx_mapping = { 
-    'python': ('https://docs.python.org/3/', None),
-    'numpy': ('https://numpy.org/doc/stable/', None),
-    'scipy': ('https://docs.scipy.org/doc/scipy/', None),
-    'astropy': ('https://docs.astropy.org/en/stable/', None),
-    'matplotib': ('https://matplotlib.org/stable',None),
-    'pandas': ('https://pandas.pydata.org/docs/', None),
-    'specutils': ('https://specutils.readthedocs.io/en/stable/',None),
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3/", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+    "scipy": ("https://docs.scipy.org/doc/scipy/", None),
+    "astropy": ("https://docs.astropy.org/en/stable/", None),
+    "matplotib": ("https://matplotlib.org/stable", None),
+    "pandas": ("https://pandas.pydata.org/docs/", None),
+    "specutils": ("https://specutils.readthedocs.io/en/stable/", None),
 }
 
 # -- Options for todo extension ----------------------------------------------
 
 # If true, `todo` and `todoList` produce output, else they produce nothing.
-#todo_include_todos = True
+# todo_include_todos = True
 
 
 # These paths are either relative to html_static_path
 # or fully qualified paths (eg. https://...)
-#html_css_files = [
+# html_css_files = [
 #    "css/custom.css",
-#]
+# ]
diff --git a/docs/index.rst b/docs/index.rst
index c508ec5c..c3ba5eea 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -2,10 +2,10 @@
 ******************
 Dysh Documentation
 ******************
-``dysh`` is a Python spectral line data reduction and analysis program for singledish data with specific emphasis on data from the Green Bank Telescope.  It is currently under development in collaboration between the 
-`Green Bank Observatory <https:/greenbankobservatory.org>`_ 
-and the Laboratory for Millimeter-Wave Astronomy (LMA) 
-at the `University of Maryland (UMD) <https://www.astro.umd.edu>`_.  
+``dysh`` is a Python spectral line data reduction and analysis program for singledish data with specific emphasis on data from the Green Bank Telescope.  It is currently under development in collaboration between the
+`Green Bank Observatory <https:/greenbankobservatory.org>`_
+and the Laboratory for Millimeter-Wave Astronomy (LMA)
+at the `University of Maryland (UMD) <https://www.astro.umd.edu>`_.
 It is intended to be a full replacement for the GBO's current reduction package `GBTIDL <https://www.gb.nrao.edu/GBT/DA/gbtidl/users_guide/>`_.
 
 Getting Started
@@ -53,7 +53,7 @@ You must have a `Github account <https://github.com>`_ to submit an issue.
 
 Credits
 =======
-``dysh`` is being developed by a partnership between the Green Bank Observatory and the Laboratory for Millimeter-wave Astronomy at the University of Maryland, College Park. 
+``dysh`` is being developed by a partnership between the Green Bank Observatory and the Laboratory for Millimeter-wave Astronomy at the University of Maryland, College Park.
 
 Dev Team
 --------
diff --git a/docs/install.rst b/docs/install.rst
index f1d2ba3b..0850b98b 100644
--- a/docs/install.rst
+++ b/docs/install.rst
@@ -3,9 +3,9 @@ Installing ``dysh``
 *******************
 
 ``dysh`` requires Python 3.8+ and recent versions of
-`astropy <https://astropy.org>`_, 
+`astropy <https://astropy.org>`_,
 `numpy <https://numpy.org>`_,
-`scipy <https://scipy.org>`_, 
+`scipy <https://scipy.org>`_,
 `pandas <https://pandas.pydata.org>`_,
 `specutils <https://specutils.readthedocs.io/en/stable/>`_,  and
 `matplotlib <https://matplotlib.org>`_.
@@ -24,7 +24,7 @@ Index <https://pypi.org/project/dysh>`_.
 From github
 ===========
 
-To install from github without creating a separate virtual environment: 
+To install from github without creating a separate virtual environment:
 
 .. code::
 
@@ -37,7 +37,7 @@ If you wish to install using a virtual environment, which we strongly recommend
 Development
 ===========
 
-Here are the steps if you want to develop code for ``dysh``. 
+Here are the steps if you want to develop code for ``dysh``.
 
 Installation
 ------------
@@ -75,7 +75,7 @@ The virtual environment will be created the first time; subsequent invoking ``ha
     .. code-block:: bash
 
         (dysh) $ exit
-        $ 
+        $
 
 #.  Each time when you come back in this directory without being in this virtual environment, you'll need to load the virtual environment.
 
@@ -92,4 +92,3 @@ Testing
 .. code-block:: bash
 
     $ pytest
-
diff --git a/docs/install_developer.md b/docs/install_developer.md
index ef7279b2..049b09fa 100644
--- a/docs/install_developer.md
+++ b/docs/install_developer.md
@@ -19,10 +19,10 @@ You will need initial admin privilages for this.
      # setup a venv, for example in a $HOME/venv hierarchy
      mkdir -p $HOME/venv
      python3 -m venv $HOME/venv/dysh1
-     
+
      # activate this venv
      source $HOME/venv/dysh1/bin/activate
-     
+
      # install hatch
      pip install hatch notebook
 
@@ -37,11 +37,11 @@ After this dysh can be installed in a virtual environment controlled by hatch
      hatch shell
      pip install -r requirements_dev.txt
          # some warning about running ipython
-     pip install -r docs/requirements.txt     
+     pip install -r docs/requirements.txt
      hatch build
      pip install -e .
      ipython            # this initially gave a matplotlib error, but it went away
-     exit               
+     exit
 
 Any time development is needed:
 
@@ -67,7 +67,7 @@ this will still return to the native virtual environment, so one more exit is ne
 
 
 
-     
+
 ## dysh2: anaconda3 python
 
 Here is an example using an anaconda3 python, no virtual environments, no hatch, no nothing.
@@ -98,21 +98,21 @@ and verify
 and when done, exit will terminate the shell
 
      exit
-   
+
 
 
 
 
 ## dysh3: anaconda3 python with virtual environment
 
-Here is an example using an anaconda3 python, but now using hatch 
+Here is an example using an anaconda3 python, but now using hatch
 
      mkdir ~/GBT/dysh3
      cd ~/GBT/dysh3
 
      ../install_anaconda3                # DM me for a copy
      source python_start.sh
-     
+
      pip install hatch
 
 After this dysh can be installed in a virtual environment controlled by hatch,
@@ -124,7 +124,7 @@ pretty much following what we did in *dysh1*:
      # setup dysh with hatch (be sure to be in the dysh directory)
      hatch shell
      pip install -r requirements_dev.txt
-     pip install -r docs/requirements.txt     
+     pip install -r docs/requirements.txt
      hatch build
      pip install -e .
 
@@ -136,7 +136,7 @@ and verify
 and when done, exit will terminate the shell
 
      exit
-   
+
 
 Any time development is needed:
 
diff --git a/docs/performance.rst b/docs/performance.rst
index c916d17b..b13b79b8 100644
--- a/docs/performance.rst
+++ b/docs/performance.rst
@@ -24,4 +24,3 @@ The result is that `dysh` performs **better** than `GBTIDL` in loading and index
     :align: left
 
     Performance of `dysh` versus `GBTIDL` in common operations.  `dysh` is significantly faster in loading SDFITS files and creating indices (equivalent of GBTIDL index file) and creating spectra.  It is comparable in removing baselines of arbitrary order.  No attempt was made to optimize the prototype `dysh` code.
-
diff --git a/docs/positionswitch.rst b/docs/positionswitch.rst
index 3b1254a7..5b659695 100644
--- a/docs/positionswitch.rst
+++ b/docs/positionswitch.rst
@@ -12,7 +12,7 @@ Single beam position-switched (PS) data is retrieved using :meth:`~dysh.fits.gbt
 
 ..  (TODO need to replace fixed path with get_example_data() and explanation thereof)::
 
-Then load your SDFITS file containing PS data. In this example, we use a 
+Then load your SDFITS file containing PS data. In this example, we use a
 `GBT SDFITS file downloadable from GBO <http://www.gb.nrao.edu/dysh/example_data/onoff-L/data/TGBT21A_501_11.raw.vegas.fits>`_::
 
     >>> f = 'TGBT21A_501_11.raw.vegas.fits'
@@ -23,8 +23,8 @@ The returned `sdfits` can be probed for information::
     >>> sdfits.info()
         Filename: /data/gbt/examples/onoff-L/data/TGBT21A_501_11.raw.vegas.fits
         No.    Name      Ver    Type      Cards   Dimensions   Format
-          0  PRIMARY       1 PrimaryHDU      12   ()      
-          1  SINGLE DISH    1 BinTableHDU    245   6040R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '32768E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']   
+          0  PRIMARY       1 PrimaryHDU      12   ()
+          1  SINGLE DISH    1 BinTableHDU    245   6040R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '32768E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']
 
 You can also print a concise (or verbose if you choose `verbose=True`) summary :meth:`~dysh.fits.gbtfitsload.GBTFITSLoad.summary` of the data::
 
@@ -39,7 +39,7 @@ Retrieve a scan and its partner ON or OFF, selecting and IF number and polarizat
     >>> psscan = sdfits.getps(152, ifnum=0, plnum=0)
     >>> psscan.calibrate() # this will be eventually be subsumed into `calibrate=True` in `getps`
         PSSCAN nrows = 302
-    
+
 The system temperature array (numpy.ndarray) is stored in `tsys`::
 
     >>> print(f"T_sys = {pscan.tsys.mean():.2f}:")
@@ -64,12 +64,12 @@ Removing a baseline
 ===================
 
 Baselines can be removed from :class:`~dysh.spectra.spectrum.Spectrum` with the :meth:`~dysh.spectra.spectrum.Spectrum.baseline` function.   Users provide baseline degree and optionally exclude region in any conformable x-axis unit (e.g., frequency, velocity, channel).  The default model is polynomial (:class:`~astropy.modeling.polynomial.Polynomial1D`) but a Chebyshev series (:class:`~astropy.modeling.polynomial.Chebyshev1D`)
-is also .  The baseline is removed if `remove=True`. 
+is also .  The baseline is removed if `remove=True`.
 
     >>> kms = u.km/u.s
     >>> ta.baseline(order=2,exclude=[3600,4100]*kms, remove=True)
     EXCLUDING [Spectral Region, 1 sub-regions:
-      (1401242184.363393 Hz, 1403551474.1090915 Hz) 
+      (1401242184.363393 Hz, 1403551474.1090915 Hz)
     ]
     >>> ta.plot(ymin=-200)
     >>> print(ta.baseline_model)Model: Polynomial1D
@@ -78,10 +78,9 @@ is also .  The baseline is removed if `remove=True`.
     Model set size: 1
     Degree: 2
     Parameters:
-                 c0                   c1                    c2          
-                 K                  K / Hz               K / Hz2        
+                 c0                   c1                    c2
+                 K                  K / Hz               K / Hz2
         ------------------- --------------------- ----------------------
         0.16984671256725348 6.155580136474429e-29 2.2305011385559243e-56
 
 .. image:: static/ps_152_baseline_removed.png
-
diff --git a/docs/subbeamnod.rst b/docs/subbeamnod.rst
index d274fd0a..953eb5ee 100644
--- a/docs/subbeamnod.rst
+++ b/docs/subbeamnod.rst
@@ -1,5 +1,5 @@
 ***************
-SubBeamNod Data 
+SubBeamNod Data
 ***************
 
 Calibrating SubBeamNod Data
@@ -12,7 +12,7 @@ SubBeamNod data, where a single pixel in a pixel camera is used to do a beam nod
 
 ..  (TODO need to replace fixed path with get_example_data() and explanation thereof)::
 
-Then load your SDFITS file containing SubBeamNod data. In this example, we use a 
+Then load your SDFITS file containing SubBeamNod data. In this example, we use a
 `GBT SDFITS file downloadable from GBO <http://www.gb.nrao.edu/dysh/example_data/subbeamnod-Ka/data/TRCO_230413_Ka.raw.vegas/TRCO_230413_Ka.raw.vegas.A.fits'>_``
 
     >>> f = 'TRCO_230413_Ka.raw.vegas.A.fits'
@@ -23,8 +23,8 @@ The returned `sdfits` can be probed for information::
     >>> sdfits.info()
     Filename: /data/gbt/examples/subbeamnod-Ka/data/TRCO_230413_Ka.raw.vegas/TRCO_230413_Ka.raw.vegas.A.fits
     No.    Name      Ver    Type      Cards   Dimensions   Format
-      0  PRIMARY       1 PrimaryHDU      12   ()      
-      1  SINGLE DISH    1 BinTableHDU    245   5280R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '1024E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']   
+      0  PRIMARY       1 PrimaryHDU      12   ()
+      1  SINGLE DISH    1 BinTableHDU    245   5280R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '1024E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']
 
 You can also print a concise (or verbose if you choose `verbose=True`) summary :meth:`~dysh.fits.gbtfitsload.GBTFITSLoad.summary` of the data::
 
@@ -53,4 +53,3 @@ The SubBeamNod scans are 43, 46, and 54.  Retrieve and calibrate a SubBeamNod sc
 
     >>> sbn = sdfits.subbeamnod(scan=43,fdnum=1,ifnum=0,weights='tsys')
     >>> sbn.plot()
-
diff --git a/docs/totalpower.rst b/docs/totalpower.rst
index 8f38a837..de4bacdc 100644
--- a/docs/totalpower.rst
+++ b/docs/totalpower.rst
@@ -12,7 +12,7 @@ Single beam total power (TP) data is retrieved using :meth:`~dysh.fits.gbtfitslo
 
 ..  (TODO need to replace fixed path with get_example_data() and explanation thereof)::
 
-Then load your SDFITS file containing TP data. In this example, we use a 
+Then load your SDFITS file containing TP data. In this example, we use a
 `GBT SDFITS file downloadable from GBO <http://www.gb.nrao.edu/dysh/example_data/onoff-L/data/TGBT21A_501_11.raw.vegas.fits>`_::
 
     >>> f = 'TGBT21A_501_11.raw.vegas.fits'
@@ -23,8 +23,8 @@ The returned `sdfits` can be probed for information::
     >>> sdfits.info()
         Filename: /data/gbt/examples/onoff-L/data/TGBT21A_501_11.raw.vegas.fits
         No.    Name      Ver    Type      Cards   Dimensions   Format
-          0  PRIMARY       1 PrimaryHDU      12   ()      
-          1  SINGLE DISH    1 BinTableHDU    245   6040R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '32768E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']   
+          0  PRIMARY       1 PrimaryHDU      12   ()
+          1  SINGLE DISH    1 BinTableHDU    245   6040R x 74C   ['32A', '1D', '22A', '1D', '1D', '1D', '32768E', '16A', '6A', '8A', '1D', '1D', '1D', '4A', '1D', '4A', '1D', '1I', '32A', '32A', '1J', '32A', '16A', '1E', '8A', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '1D', '8A', '1D', '1D', '12A', '1I', '1I', '1D', '1D', '1I', '1A', '1I', '1I', '16A', '16A', '1J', '1J', '22A', '1D', '1D', '1I', '1A', '1D', '1E', '1D', '1D', '1D', '1D', '1D', '1A', '1A', '8A', '1E', '1E', '16A', '1I', '1I', '1I']
 
 You can also print a concise (or verbose if you choose `verbose=True`) summary :meth:`~dysh.fits.gbtfitsload.GBTFITSLoad.summary` of the data::
 
diff --git a/dysh_start.sh.in b/dysh_start.sh.in
index 5b751f90..9849e9fc 100644
--- a/dysh_start.sh.in
+++ b/dysh_start.sh.in
@@ -10,4 +10,3 @@ for f in $DYSH/dysh_local.sh $HOME/.dysh_start.sh; do
 	source $f
     fi
 done
-
diff --git a/notebooks/developer/README.md b/notebooks/developer/README.md
index dea457cb..f5643256 100644
--- a/notebooks/developer/README.md
+++ b/notebooks/developer/README.md
@@ -1,4 +1,2 @@
 # Developer notebooks
 This directory contains jupyter notebooks used by the dev team in development and debugging.  There is no guarantee they work at any given time.
-
-
diff --git a/requirements.txt b/requirements.txt
index 8a78687a..1e10f731 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,12 +1,291 @@
-astropy
-matplotlib
-numpy
-pandas
-scipy
-specutils
-myst_parser
-hatch
-pytest
-sphinx_rtd_theme
-sphinxcontrib_mermaid
-wget
\ No newline at end of file
+#
+# This file is autogenerated by pip-compile with Python 3.9
+# by the following command:
+#
+#    pip-compile --all-extras --output-file=requirements.txt pyproject.toml
+#
+--trusted-host pypi.gb.nrao.edu
+
+alabaster==0.7.13
+    # via sphinx
+asdf==2.15.1
+    # via
+    #   asdf-astropy
+    #   asdf-coordinates-schemas
+    #   asdf-wcs-schemas
+    #   gwcs
+    #   specutils
+asdf-astropy==0.4.0
+    # via
+    #   gwcs
+    #   specutils
+asdf-coordinates-schemas==0.2.0
+    # via asdf-astropy
+asdf-standard==1.0.3
+    # via
+    #   asdf
+    #   asdf-transform-schemas
+    #   asdf-unit-schemas
+asdf-transform-schemas==0.3.0
+    # via
+    #   asdf
+    #   asdf-astropy
+asdf-unit-schemas==0.1.0
+    # via asdf
+asdf-wcs-schemas==0.1.1
+    # via gwcs
+astropy==5.3.2
+    # via
+    #   asdf-astropy
+    #   dysh (pyproject.toml)
+    #   gwcs
+    #   ndcube
+    #   specutils
+asttokens==2.2.1
+    # via stack-data
+attrs==23.1.0
+    # via
+    #   asdf
+    #   jsonschema
+    #   referencing
+babel==2.12.1
+    # via sphinx
+backcall==0.2.0
+    # via ipython
+certifi==2023.7.22
+    # via requests
+charset-normalizer==3.2.0
+    # via requests
+colorama==0.4.6
+    # via sphinx-autobuild
+contourpy==1.1.0
+    # via matplotlib
+coverage[toml]==7.3.0
+    # via pytest-cov
+cycler==0.11.0
+    # via matplotlib
+decorator==5.1.1
+    # via
+    #   ipdb
+    #   ipython
+docutils==0.18.1
+    # via
+    #   myst-parser
+    #   sphinx
+    #   sphinx-rtd-theme
+exceptiongroup==1.1.3
+    # via pytest
+executing==1.2.0
+    # via stack-data
+fonttools==4.42.1
+    # via matplotlib
+gwcs==0.18.3
+    # via
+    #   ndcube
+    #   specutils
+idna==3.4
+    # via requests
+imagesize==1.4.1
+    # via sphinx
+importlib-metadata==6.8.0
+    # via
+    #   asdf
+    #   sphinx
+importlib-resources==6.0.1
+    # via matplotlib
+iniconfig==2.0.0
+    # via pytest
+ipdb==0.13.13
+    # via dysh (pyproject.toml)
+ipython==8.14.0
+    # via
+    #   dysh (pyproject.toml)
+    #   ipdb
+jedi==0.19.0
+    # via ipython
+jinja2==3.1.2
+    # via
+    #   myst-parser
+    #   numpydoc
+    #   sphinx
+jmespath==1.0.1
+    # via asdf
+jsonschema==4.19.0
+    # via asdf
+jsonschema-specifications==2023.7.1
+    # via jsonschema
+kiwisolver==1.4.5
+    # via matplotlib
+livereload==2.6.3
+    # via sphinx-autobuild
+markdown-it-py==3.0.0
+    # via
+    #   mdit-py-plugins
+    #   myst-parser
+markupsafe==2.1.3
+    # via jinja2
+matplotlib==3.7.2
+    # via dysh (pyproject.toml)
+matplotlib-inline==0.1.6
+    # via ipython
+mdit-py-plugins==0.4.0
+    # via myst-parser
+mdurl==0.1.2
+    # via markdown-it-py
+myst-parser==2.0.0
+    # via dysh (pyproject.toml)
+ndcube==2.1.3
+    # via specutils
+numpy==1.25.2
+    # via
+    #   asdf
+    #   asdf-astropy
+    #   astropy
+    #   contourpy
+    #   dysh (pyproject.toml)
+    #   gwcs
+    #   matplotlib
+    #   ndcube
+    #   pandas
+    #   pyerfa
+    #   scipy
+    #   specutils
+numpydoc==1.5.0
+    # via dysh (pyproject.toml)
+packaging==23.1
+    # via
+    #   asdf
+    #   asdf-astropy
+    #   astropy
+    #   matplotlib
+    #   pytest
+    #   sphinx
+pandas==2.0.3
+    # via dysh (pyproject.toml)
+parso==0.8.3
+    # via jedi
+pexpect==4.8.0
+    # via ipython
+pickleshare==0.7.5
+    # via ipython
+pillow==10.0.0
+    # via matplotlib
+pluggy==1.2.0
+    # via pytest
+prompt-toolkit==3.0.39
+    # via ipython
+ptyprocess==0.7.0
+    # via pexpect
+pure-eval==0.2.2
+    # via stack-data
+pyerfa==2.0.0.3
+    # via astropy
+pygments==2.16.1
+    # via
+    #   ipython
+    #   sphinx
+pyparsing==3.0.9
+    # via matplotlib
+pytest==7.4.0
+    # via
+    #   dysh (pyproject.toml)
+    #   pytest-cov
+pytest-cov==4.1.0
+    # via dysh (pyproject.toml)
+python-dateutil==2.8.2
+    # via
+    #   matplotlib
+    #   pandas
+pytz==2023.3
+    # via pandas
+pyyaml==6.0.1
+    # via
+    #   asdf
+    #   astropy
+    #   myst-parser
+referencing==0.30.2
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+requests==2.31.0
+    # via sphinx
+rpds-py==0.9.2
+    # via
+    #   jsonschema
+    #   referencing
+scipy==1.11.2
+    # via
+    #   dysh (pyproject.toml)
+    #   gwcs
+    #   specutils
+semantic-version==2.10.0
+    # via asdf
+six==1.16.0
+    # via
+    #   asttokens
+    #   livereload
+    #   python-dateutil
+snowballstemmer==2.2.0
+    # via sphinx
+specutils==1.11.0
+    # via dysh (pyproject.toml)
+sphinx==7.2.3
+    # via
+    #   dysh (pyproject.toml)
+    #   myst-parser
+    #   numpydoc
+    #   sphinx-autobuild
+    #   sphinx-rtd-theme
+    #   sphinxcontrib-applehelp
+    #   sphinxcontrib-devhelp
+    #   sphinxcontrib-htmlhelp
+    #   sphinxcontrib-jquery
+    #   sphinxcontrib-qthelp
+    #   sphinxcontrib-serializinghtml
+sphinx-autobuild==2021.3.14
+    # via dysh (pyproject.toml)
+sphinx-rtd-theme==1.3.0
+    # via dysh (pyproject.toml)
+sphinxcontrib-applehelp==1.0.7
+    # via sphinx
+sphinxcontrib-devhelp==1.0.5
+    # via sphinx
+sphinxcontrib-htmlhelp==2.0.4
+    # via sphinx
+sphinxcontrib-jquery==4.1
+    # via sphinx-rtd-theme
+sphinxcontrib-jsmath==1.0.1
+    # via sphinx
+sphinxcontrib-mermaid==0.9.2
+    # via dysh (pyproject.toml)
+sphinxcontrib-qthelp==1.0.6
+    # via sphinx
+sphinxcontrib-serializinghtml==1.1.9
+    # via sphinx
+stack-data==0.6.2
+    # via ipython
+tomli==2.0.1
+    # via
+    #   coverage
+    #   ipdb
+    #   pytest
+tornado==6.3.3
+    # via livereload
+traitlets==5.9.0
+    # via
+    #   ipython
+    #   matplotlib-inline
+typing-extensions==4.7.1
+    # via ipython
+tzdata==2023.3
+    # via pandas
+urllib3==2.0.4
+    # via requests
+wcwidth==0.2.6
+    # via prompt-toolkit
+wget==3.2
+    # via dysh (pyproject.toml)
+zipp==3.16.2
+    # via
+    #   importlib-metadata
+    #   importlib-resources
diff --git a/requirements_dev.txt b/requirements_dev.txt
index f3def438..09f72642 100644
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@@ -12,4 +12,4 @@ black
 sphinx_rtd_theme
 sphinxcontrib_mermaid
 myst_parser
-wget
\ No newline at end of file
+wget
diff --git a/src/dysh/__init__.py b/src/dysh/__init__.py
index 1ba2359f..a3c4f880 100644
--- a/src/dysh/__init__.py
+++ b/src/dysh/__init__.py
@@ -3,6 +3,7 @@
 
 all = ["version"]
 
+
 def version():
     """Version of the dysh code
 
diff --git a/src/dysh/_dysh_init.py b/src/dysh/_dysh_init.py
index fe157263..42dc57d3 100644
--- a/src/dysh/_dysh_init.py
+++ b/src/dysh/_dysh_init.py
@@ -6,7 +6,6 @@
 
 import specutils
 
-
 logger = logging.getLogger(__name__)
 
 
diff --git a/src/dysh/fits/__init__.py b/src/dysh/fits/__init__.py
index d6614fc7..cc949b3d 100644
--- a/src/dysh/fits/__init__.py
+++ b/src/dysh/fits/__init__.py
@@ -1,2 +1,2 @@
 """Classes and functions for importing SDFITS files"""
-__all__ = [ "gbtfitsload", "sdfitsload" ]
+__all__ = ["gbtfitsload", "sdfitsload"]
diff --git a/src/dysh/fits/gbtfitsload.py b/src/dysh/fits/gbtfitsload.py
index 2f854a3b..fc750271 100644
--- a/src/dysh/fits/gbtfitsload.py
+++ b/src/dysh/fits/gbtfitsload.py
@@ -1,66 +1,60 @@
 """Load SDFITS files produced by the Green Bank Telescope"""
-import sys
 import copy
-import warnings
-from astropy.wcs import WCS
-from astropy.units import cds
-from astropy.io import fits
-from astropy.modeling import models, fitting
+
 import astropy.units as u
-from astropy.table import Table
-import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
+import pandas as pd
+from astropy.io import fits
 
 from ..spectra.core import tsys_weight
-from ..spectra.spectrum import Spectrum
-from ..spectra.scan import GBTPSScan,GBTTPScan
-from ..spectra.obsblock import Obsblock
+from ..spectra.scan import GBTPSScan, GBTTPScan
+from ..util import consecutive, uniq
 from .sdfitsload import SDFITSLoad
-from ..util import uniq, consecutive
 
 # from GBT IDL users guide Table 6.7
-_PROCEDURES = ["Track", "OnOff", "OffOn", "OffOnSameHA", "Nod", "SubBeamNod"] 
+_PROCEDURES = ["Track", "OnOff", "OffOn", "OffOnSameHA", "Nod", "SubBeamNod"]
+
 
 class GBTFITSLoad(SDFITSLoad):
     """GBT-specific container for bintables from selected HDU(s)"""
-    def __init__(self, filename, source=None,hdu=None,**kwargs):
-        SDFITSLoad.__init__(self,filename,source,hdu)#,fix=False)
+
+    def __init__(self, filename, source=None, hdu=None, **kwargs):
+        SDFITSLoad.__init__(self, filename, source, hdu)  # ,fix=False)
 
         self._compute_proc()
-        if kwargs.get("verbose",None):
+        if kwargs.get("verbose", None):
             print("==GBTLoad %s" % filename)
-            self.ushow(0,'OBJECT')
-            self.ushow(0,'SCAN')
-            self.ushow(0,'SAMPLER')
-            self.ushow('PLNUM')
-            self.ushow('IFNUM')
-            self.ushow(0,'SIG')
-            self.ushow(0,'CAL')
-            self.ushow(0,'PROCSEQN')
-            self.ushow(0,'PROCSIZE')
-            self.ushow(0,'OBSMODE')  
-            self.ushow(0,'SIDEBAND')
+            self.ushow(0, "OBJECT")
+            self.ushow(0, "SCAN")
+            self.ushow(0, "SAMPLER")
+            self.ushow("PLNUM")
+            self.ushow("IFNUM")
+            self.ushow(0, "SIG")
+            self.ushow(0, "CAL")
+            self.ushow(0, "PROCSEQN")
+            self.ushow(0, "PROCSIZE")
+            self.ushow(0, "OBSMODE")
+            self.ushow(0, "SIDEBAND")
 
     def _compute_proc(self):
         """Compute the procedure string from obsmode and add to index"""
         for i in range(len(self._ptable)):
-            df = self._ptable[i]["OBSMODE"].str.split(':',expand=True)
+            df = self._ptable[i]["OBSMODE"].str.split(":", expand=True)
             self._ptable[i]["PROC"] = df[0]
             # Assign these to something that might be usefule later, since we have them
             self._ptable[i]["_OBSTYPE"] = df[1]
             self._ptable[i]["_SUBOBSMODE"] = df[2]
 
     def summary(self, scans=None, verbose=False, bintable=0):
-# From GBTIDL:
-# Intended to work with un-calibrated GBT data and is
-# likely to give confusing results for other data.  For other data,
-# list is usually more useful.
-#
-# @TODO perhaps return as a astropy.Table then we can have units
-        """Create a summary list of the input dataset.   
-            If `verbose=False` (default), some numeric data 
-            (e.g., RESTFREQ, AZIMUTH, ELEVATIO) are 
+        # From GBTIDL:
+        # Intended to work with un-calibrated GBT data and is
+        # likely to give confusing results for other data.  For other data,
+        # list is usually more useful.
+        #
+        # @TODO perhaps return as a astropy.Table then we can have units
+        """Create a summary list of the input dataset.
+            If `verbose=False` (default), some numeric data
+            (e.g., RESTFREQ, AZIMUTH, ELEVATIO) are
             averaged over the records with the same scan number.
 
         Parameters
@@ -75,60 +69,85 @@ def summary(self, scans=None, verbose=False, bintable=0):
         -------
             summary - `~pandas.DataFrame`
                 Summary of the data as a DataFrame.
-            
+
         """
-        #@todo allow user to change show list
-        #@todo set individual format options on output by
+        # @todo allow user to change show list
+        # @todo set individual format options on output by
         # changing these to dicts(?)
         #
-        # 'show' is fragile because anything we might need to query in 'uf' below in 
-        # order to do a calculation,  whether we want to show it, or not must be in 'show.'  
+        # 'show' is fragile because anything we might need to query in 'uf' below in
+        # order to do a calculation,  whether we want to show it, or not must be in 'show.'
         # (e.g. PROCSIZE is needed to calculate n_integrations).
-        show = ["SCAN", "OBJECT", "VELOCITY", "PROC", "PROCSEQN", "PROCSIZE",
-                "RESTFREQ", "DOPFREQ", "IFNUM","FEED", "AZIMUTH", "ELEVATIO", 
-                "FDNUM", "PLNUM", "SIG", "CAL","DATE-OBS"] 
+        show = [
+            "SCAN",
+            "OBJECT",
+            "VELOCITY",
+            "PROC",
+            "PROCSEQN",
+            "PROCSIZE",
+            "RESTFREQ",
+            "DOPFREQ",
+            "IFNUM",
+            "FEED",
+            "AZIMUTH",
+            "ELEVATIO",
+            "FDNUM",
+            "PLNUM",
+            "SIG",
+            "CAL",
+            "DATE-OBS",
+        ]
         comp_colnames = [
-                "SCAN", "OBJECT", "VELOCITY", "PROC", "PROCSEQN", 
-                "RESTFREQ", "DOPFREQ", "# IF","# POL", "# INT", "# FEED", 
-                "AZIMUTH", "ELEVATIO"]
+            "SCAN",
+            "OBJECT",
+            "VELOCITY",
+            "PROC",
+            "PROCSEQN",
+            "RESTFREQ",
+            "DOPFREQ",
+            "# IF",
+            "# POL",
+            "# INT",
+            "# FEED",
+            "AZIMUTH",
+            "ELEVATIO",
+        ]
         uncompressed_df = None
         if self._ptable is None:
             self._create_index()
         for df in self._ptable:
-            # make a copy here because we can't guarantee if this is a 
+            # make a copy here because we can't guarantee if this is a
             # view or a copy without it. See https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
             _df = df[show].copy()
-            _df.loc[:,"VELOCITY"] /= 1E3   # convert to km/s
-            _df["RESTFREQ"] = _df["RESTFREQ"]/1.0E9 # convert to GHz
-            _df["DOPFREQ"] = _df["DOPFREQ"]/1.0E9 # convert to GHz
+            _df.loc[:, "VELOCITY"] /= 1e3  # convert to km/s
+            _df["RESTFREQ"] = _df["RESTFREQ"] / 1.0e9  # convert to GHz
+            _df["DOPFREQ"] = _df["DOPFREQ"] / 1.0e9  # convert to GHz
             if scans is not None:
                 if type(scans) == int:
                     scans = [scans]
                 if len(scans) == 1:
-                    scans = [scans[0],scans[0]] # or should this be [scans[0],lastscan]?
-                _df = self.select_scans(scans,_df).filter(show)
+                    scans = [scans[0], scans[0]]  # or should this be [scans[0],lastscan]?
+                _df = self.select_scans(scans, _df).filter(show)
                 if uncompressed_df is None:
                     uncompressed_df = _df
                 else:
-                    uncompressed_df =pd.concat([uncompressed_df,_df])
+                    uncompressed_df = pd.concat([uncompressed_df, _df])
             else:
                 if uncompressed_df is None:
                     uncompressed_df = _df.filter(show)
                 else:
-                    uncompressed_df = pd.concat([uncompressed_df,_df.filter(show)])
-        
+                    uncompressed_df = pd.concat([uncompressed_df, _df.filter(show)])
+
         if verbose:
             return uncompressed_df
-        # do the work to compress the info 
+        # do the work to compress the info
         # in the dataframe on a scan basis
-        compressed_df = pd.DataFrame(columns = comp_colnames)
+        compressed_df = pd.DataFrame(columns=comp_colnames)
         scanset = set(uncompressed_df["SCAN"])
-        avg_cols = ["SCAN", "VELOCITY", "PROCSEQN", 
-                    "RESTFREQ", "DOPFREQ",
-                    "AZIMUTH", "ELEVATIO"]
+        avg_cols = ["SCAN", "VELOCITY", "PROCSEQN", "RESTFREQ", "DOPFREQ", "AZIMUTH", "ELEVATIO"]
         for s in scanset:
-            uf = self.select("SCAN",s,uncompressed_df)
-            # for some columns we will display 
+            uf = self.select("SCAN", s, uncompressed_df)
+            # for some columns we will display
             # the mean value
             ser = uf.filter(avg_cols).mean(numeric_only=True)
             ser.rename("filtered ser")
@@ -136,36 +155,35 @@ def summary(self, scans=None, verbose=False, bintable=0):
             nIF = uf["IFNUM"].nunique()
             nPol = uf["PLNUM"].nunique()
             nfeed = uf["FEED"].nunique()
-            nint = len(set(uf["DATE-OBS"])) # see gbtidl io/line_index__define.pro
-            obj = list(set(uf["OBJECT"]))[0] # We assume they are all the same!
-            proc = list(set(uf["PROC"]))[0] # We assume they are all the same!
-            #print(f"Uniq data for scan {s}: {nint} {nIF} {nPol} {nfeed} {obj} {proc}")
-            s2 = pd.Series([obj,proc,nIF,nPol,nint,nfeed],
-                    name = "uniqued data",
-                    index=["OBJECT","PROC",
-                           "# IF","# POL", "# INT","# FEED"])
-            ser=pd.concat([ser,s2]).reindex(comp_colnames)
+            nint = len(set(uf["DATE-OBS"]))  # see gbtidl io/line_index__define.pro
+            obj = list(set(uf["OBJECT"]))[0]  # We assume they are all the same!
+            proc = list(set(uf["PROC"]))[0]  # We assume they are all the same!
+            # print(f"Uniq data for scan {s}: {nint} {nIF} {nPol} {nfeed} {obj} {proc}")
+            s2 = pd.Series(
+                [obj, proc, nIF, nPol, nint, nfeed],
+                name="uniqued data",
+                index=["OBJECT", "PROC", "# IF", "# POL", "# INT", "# FEED"],
+            )
+            ser = pd.concat([ser, s2]).reindex(comp_colnames)
             ser.rename("appended ser")
-            #print("append series data",ser)
-            #print("append series index ",ser.index)
-            #print("df cols",compressed_df.columns)
-            #print("SAME? ",all(ser.index == compressed_df.columns))
-            compressed_df = pd.concat(
-                    [compressed_df,ser.to_frame().T],
-                    ignore_index=True)
+            # print("append series data",ser)
+            # print("append series index ",ser.index)
+            # print("df cols",compressed_df.columns)
+            # print("SAME? ",all(ser.index == compressed_df.columns))
+            compressed_df = pd.concat([compressed_df, ser.to_frame().T], ignore_index=True)
         return compressed_df
 
-    def velocity_convention(self,veldef,velframe):
-        # GBT uses VELDEF and VELFRAME incorrectly. 
+    def velocity_convention(self, veldef, velframe):
+        # GBT uses VELDEF and VELFRAME incorrectly.
         return "doppler_radio"
 
-    def select_scans(self,scans,df):
-        return df[(df["SCAN"]>=scans[0]) & ( df["SCAN"] <= scans[1])]
+    def select_scans(self, scans, df):
+        return df[(df["SCAN"] >= scans[0]) & (df["SCAN"] <= scans[1])]
 
-    def select_onoff(self,df):
-        return df[(df["PROC"]=="OnOff") | ( df["PROC"] == "OffOn")]
+    def select_onoff(self, df):
+        return df[(df["PROC"] == "OnOff") | (df["PROC"] == "OffOn")]
 
-    def select(self,key,value,df):
+    def select(self, key, value, df):
         """Select data where key=value
 
         Parameters
@@ -183,19 +201,19 @@ def select(self,key,value,df):
             df : `~pandas.DataFrame`
                 The subselected DataFrame
         """
-        return df[(df[key]==value)]
+        return df[(df[key] == value)]
 
     def _create_index_if_needed(self):
         if self._ptable is None:
             self._create_index()
 
-#        TODO: figure how to allow [startscan, endscan]
-#            [sampler], ap_eff [if requested units are Jy]
-    def getps(self,scans=None,bintable=0,**kwargs):
-        '''Get the rows that contain position-switched data.  These include ONs and OFFs.
+    #        TODO: figure how to allow [startscan, endscan]
+    #            [sampler], ap_eff [if requested units are Jy]
+    def getps(self, scans=None, bintable=0, **kwargs):
+        """Get the rows that contain position-switched data.  These include ONs and OFFs.
 
            kwargs: plnum, feed, ifnum, integration, calibrate=T/F, average=T/F, tsys, weights
-            
+
         Parameters
         ----------
             scans : int or 2-tuple
@@ -204,37 +222,37 @@ def getps(self,scans=None,bintable=0,**kwargs):
             weights: str
                 'equal' or 'tsys' to indicate equal weighting or tsys weighting to use in time averaging. Default: 'tsys'
 
-        Returns 
+        Returns
         -------
             psscan : `~spectra.scan.GBTPSScan`
                 A `GBTPScan` object containing the data which can be calibrated.
-        '''
+        """
         # all ON/OFF scans
         kwargs_opts = {
-            'ifnum': 0,
-            'plnum' : 0, # I prefer "pol"
-            'fdnum' : 0,
-            'calibrate': True,
-            'timeaverage': False,
-            'polaverage': False,
-            'tsys': None,
-            'weights': 'tsys',
+            "ifnum": 0,
+            "plnum": 0,  # I prefer "pol"
+            "fdnum": 0,
+            "calibrate": True,
+            "timeaverage": False,
+            "polaverage": False,
+            "tsys": None,
+            "weights": "tsys",
         }
         kwargs_opts.update(kwargs)
 
-        ifnum = kwargs_opts['ifnum']
-        plnum = kwargs_opts['plnum']
-        scanlist = self.onoff_scan_list(scans,ifnum=ifnum,plnum=plnum,bintable=bintable)
+        ifnum = kwargs_opts["ifnum"]
+        plnum = kwargs_opts["plnum"]
+        scanlist = self.onoff_scan_list(scans, ifnum=ifnum, plnum=plnum, bintable=bintable)
         # add ifnum,plnum
-        rows = self.onoff_rows(scans,ifnum=ifnum,plnum=plnum,bintable=bintable)
-        # do not pass scan list here. We need all the cal rows. They will 
+        rows = self.onoff_rows(scans, ifnum=ifnum, plnum=plnum, bintable=bintable)
+        # do not pass scan list here. We need all the cal rows. They will
         # be intersected with scan rows in GBTPSScan
         # add ifnum,plnum
-        calrows = self.calonoff_rows(scans=None,bintable=bintable)
-        g = GBTPSScan(self,scanlist,rows,calrows,bintable)
+        calrows = self.calonoff_rows(scans=None, bintable=bintable)
+        g = GBTPSScan(self, scanlist, rows, calrows, bintable)
         return g
 
-    def gettp(self,scan,sig=None,cal=None,bintable=0,**kwargs):
+    def gettp(self, scan, sig=None, cal=None, bintable=0, **kwargs):
         """Get a total power scan, optionally calibrating it.
 
         Parameters
@@ -260,68 +278,68 @@ def gettp(self,scan,sig=None,cal=None,bintable=0,**kwargs):
                 A Spectrum object containing the data
         """
         kwargs_opts = {
-                'ifnum': 0,
-                'plnum' : 0, 
-                'fdnum' : 0,
-                'subref': None, # subreflector position
-                'timeaverage' : True,
-                'polaverage': True,
-                'weights' : 'tsys', # or 'tsys' or ndarray
-                'calibrate': True,
-                'debug': False,
-        }   
+            "ifnum": 0,
+            "plnum": 0,
+            "fdnum": 0,
+            "subref": None,  # subreflector position
+            "timeaverage": True,
+            "polaverage": True,
+            "weights": "tsys",  # or 'tsys' or ndarray
+            "calibrate": True,
+            "debug": False,
+        }
         kwargs_opts.update(kwargs)
-        TF = {True: 'T', False:'F'}
-        sigstate = {True: 'SIG', False:'REF', None:'BOTH'}
-        calstate = {True: 'ON', False:'OFF', None:'BOTH'}
-
-        ifnum = kwargs_opts['ifnum']
-        plnum = kwargs_opts['plnum']
-        fdnum =kwargs_opts['fdnum']
-        subref = kwargs_opts['subref']
+        TF = {True: "T", False: "F"}
+        sigstate = {True: "SIG", False: "REF", None: "BOTH"}
+        calstate = {True: "ON", False: "OFF", None: "BOTH"}
+
+        ifnum = kwargs_opts["ifnum"]
+        plnum = kwargs_opts["plnum"]
+        fdnum = kwargs_opts["fdnum"]
+        subref = kwargs_opts["subref"]
         df = self._ptable[0]
         df = df[(df["SCAN"] == scan)]
         if sig is not None:
             sigch = TF[sig]
-            df = df[(df['SIG']==sigch)]
-            if kwargs_opts['debug']:
-                print('S ',len(df))
+            df = df[(df["SIG"] == sigch)]
+            if kwargs_opts["debug"]:
+                print("S ", len(df))
         if cal is not None:
             calch = TF[cal]
-            df = df[df['CAL']==calch]
-            if kwargs_opts['debug']:
-                print('C ',len(df))
+            df = df[df["CAL"] == calch]
+            if kwargs_opts["debug"]:
+                print("C ", len(df))
         if ifnum is not None:
-            df = df[df['IFNUM']==ifnum]
-            if kwargs_opts['debug']:
-                print('I ',len(df))
+            df = df[df["IFNUM"] == ifnum]
+            if kwargs_opts["debug"]:
+                print("I ", len(df))
         if plnum is not None:
-            df = df[df['PLNUM']==plnum]
-            if kwargs_opts['debug']:
-                print('P ',len(df))
+            df = df[df["PLNUM"] == plnum]
+            if kwargs_opts["debug"]:
+                print("P ", len(df))
         if fdnum is not None:
-            df = df[df['FDNUM']==fdnum]
-            if kwargs_opts['debug']:
-                print('F ',len(df))
+            df = df[df["FDNUM"] == fdnum]
+            if kwargs_opts["debug"]:
+                print("F ", len(df))
         if subref is not None:
-            df = df[df['SUBREF_STATE']==subref]
-            if kwargs_opts['debug']:
-                print('SR ',len(df))
-        #TBD: if ifnum is none then we will have to sort these by ifnum, plnum and store separate arrays or something. 
+            df = df[df["SUBREF_STATE"] == subref]
+            if kwargs_opts["debug"]:
+                print("SR ", len(df))
+        # TBD: if ifnum is none then we will have to sort these by ifnum, plnum and store separate arrays or something.
         tprows = list(df.index)
-        #data = self.rawspectra(bintable)[tprows]
-        calrows = self.calonoff_rows(scans=scan,bintable=bintable,**kwargs_opts)
-        if kwargs_opts['debug']:
-            print("TPROWS len=",len(tprows))
-            print("CALROWS on len=",len(calrows['ON']))
+        # data = self.rawspectra(bintable)[tprows]
+        calrows = self.calonoff_rows(scans=scan, bintable=bintable, **kwargs_opts)
+        if kwargs_opts["debug"]:
+            print("TPROWS len=", len(tprows))
+            print("CALROWS on len=", len(calrows["ON"]))
 
-        g = GBTTPScan(self,scan,sigstate[sig],calstate[cal],tprows,calrows,bintable,kwargs_opts['calibrate'])
+        g = GBTTPScan(self, scan, sigstate[sig], calstate[cal], tprows, calrows, bintable, kwargs_opts["calibrate"])
         return g
 
     # Inspired by Dave Frayer's snodka: /users/dfrayer/gbtidlpro/snodka
     # TODO: Figure out when, if done, the fix to the Ka beam labelling took place.
     # TODO: sig and ref parameters no longer needed? Fix description of calibrate keyword, or possibly eliminate it.
-    def subbeamnod(self,scan,bintable=0,**kwargs):
+    def subbeamnod(self, scan, bintable=0, **kwargs):
         """Get a subbeam nod power scan, optionally calibrating it.
 
         Parameters
@@ -349,20 +367,20 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
                 A Spectrum object containing the data
         """
         kwargs_opts = {
-                'ifnum': 0,
-                'fdnum' : 0,
-                'timeaverage' : True,
-                'weights' : 'tsys', # or None or ndarray
-                'calibrate' : True,
-                'debug' : False,
-                'method': 'cycle',
-        } 
+            "ifnum": 0,
+            "fdnum": 0,
+            "timeaverage": True,
+            "weights": "tsys",  # or None or ndarray
+            "calibrate": True,
+            "debug": False,
+            "method": "cycle",
+        }
         kwargs_opts.update(kwargs)
-        ifnum = kwargs_opts['ifnum']
-        fdnum = kwargs_opts['fdnum']
-        docal = kwargs_opts['calibrate']
-        w = kwargs_opts['weights']
-        method = kwargs_opts['method']
+        ifnum = kwargs_opts["ifnum"]
+        fdnum = kwargs_opts["fdnum"]
+        docal = kwargs_opts["calibrate"]
+        w = kwargs_opts["weights"]
+        method = kwargs_opts["method"]
 
         # Check if we are dealing with Ka data before the beam switch.
         df = self._ptable[bintable]
@@ -370,14 +388,14 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
         rx = np.unique(df["FRONTEND"])
         if len(rx) > 1:
             raise TypeError("More than one receiver for the selected scan.")
-        elif rx[0] == "Rcvr26_40": # and df["DATE-OBS"][-1] < xxxx
+        elif rx[0] == "Rcvr26_40":  # and df["DATE-OBS"][-1] < xxxx
             # Switch the polarizations to match the beams.
             if fdnum == 0:
                 plnum = 1
             elif fdnum == 1:
                 plnum = 0
 
-        if method == 'cycle':
+        if method == "cycle":
             # Calibrate each cycle individually and then
             # average the calibrated data.
 
@@ -387,22 +405,22 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
             df = df[df["IFNUM"].isin([ifnum])]
             df = df[df["FDNUM"].isin([fdnum])]
             df = df[df["PLNUM"].isin([plnum])]
-            df_on = df[df["CAL"]=="T"]
-            df_off = df[df["CAL"]=="F"]
-            df_on_sig = df_on[df_on["SUBREF_STATE"]==-1]
-            df_on_ref = df_on[df_on["SUBREF_STATE"]==1]
-            df_off_sig = df_off[df_off["SUBREF_STATE"]==-1]
-            df_off_ref = df_off[df_off["SUBREF_STATE"]==1]
-            sig_on_rows  = df_on_sig.index.to_numpy()
-            ref_on_rows  = df_on_ref.index.to_numpy()
+            df_on = df[df["CAL"] == "T"]
+            df_off = df[df["CAL"] == "F"]
+            df_on_sig = df_on[df_on["SUBREF_STATE"] == -1]
+            df_on_ref = df_on[df_on["SUBREF_STATE"] == 1]
+            df_off_sig = df_off[df_off["SUBREF_STATE"] == -1]
+            df_off_ref = df_off[df_off["SUBREF_STATE"] == 1]
+            sig_on_rows = df_on_sig.index.to_numpy()
+            ref_on_rows = df_on_ref.index.to_numpy()
             sig_off_rows = df_off_sig.index.to_numpy()
             ref_off_rows = df_off_ref.index.to_numpy()
 
             # Define how large of a gap between rows we will tolerate to consider
             # a row as part of a cycle.
-            # Thinking about it, we should use the SUBREF_STATE=0 as delimiter rather 
+            # Thinking about it, we should use the SUBREF_STATE=0 as delimiter rather
             # than this.
-            stepsize = len(self.udata(0,"IFNUM"))*len(self.udata(0,"PLNUM"))*2 + 1
+            stepsize = len(self.udata(0, "IFNUM")) * len(self.udata(0, "PLNUM")) * 2 + 1
 
             ref_on_groups = consecutive(ref_on_rows, stepsize=stepsize)
             sig_on_groups = consecutive(sig_on_rows, stepsize=stepsize)
@@ -412,17 +430,17 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
             # Make sure we have enough signal and reference pairs.
             # Same number of cycles or less signal cycles.
             if len(sig_on_groups) <= len(ref_on_groups):
-                pairs = {i : i for i in range(len(sig_on_groups))}
+                pairs = {i: i for i in range(len(sig_on_groups))}
             # One more signal cycle. Re-use one reference cycle.
             elif len(sig_on_groups) - 1 == len(ref_on_groups):
-                pairs = {i : i for i in range(len(sig_on_groups))}
+                pairs = {i: i for i in range(len(sig_on_groups))}
                 pairs[len(sig_on_groups) - 1] = len(ref_on_groups) - 1
             else:
                 e = f"""There are {len(sig_on_groups)} and {len(ref_on_groups)} signal and reference cycles.
                         Try using method='scan'."""
                 raise ValueError(e)
 
-            # Define the calibrated data array, and 
+            # Define the calibrated data array, and
             # variables to store weights and exposure times.
             # @TODO: using TDIM7 is fragile if the headers ever change.
             #  nchan should be gotten from data length
@@ -430,8 +448,8 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
             # where row is a row number associated with this scan number
             nchan = int(self._ptable[bintable]["TDIM7"][0][1:-1].split(",")[0])
             ta = np.empty((len(sig_on_groups)), dtype=object)
-            ta_avg = np.zeros(nchan, dtype='d')
-            wt_avg = 0.0 # A single value for now, but it should be an array once we implement vector TSYS. 
+            ta_avg = np.zeros(nchan, dtype="d")
+            wt_avg = 0.0  # A single value for now, but it should be an array once we implement vector TSYS.
             tsys_wt = 0.0
             tsys_avg = 0.0
             exposure = 0.0
@@ -439,8 +457,7 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
             # Loop over cycles, calibrating each independently.
             groups_zip = zip(ref_on_groups, sig_on_groups, ref_off_groups, sig_off_groups)
 
-            for i,(rgon,sgon,rgoff,sgoff) in enumerate(groups_zip):
-
+            for i, (rgon, sgon, rgoff, sgoff) in enumerate(groups_zip):
                 # Do it the dysh way.
                 calrows = {"ON": rgon, "OFF": rgoff}
                 tprows = np.sort(np.hstack((rgon, rgoff)))
@@ -453,15 +470,15 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
                 # Combine sig and ref.
                 ta[i] = copy.deepcopy(sig_avg)
                 ta[i] = ta[i].new_flux_unit("K", suppress_conversion=True)
-                ta[i]._data = ((sig_avg - ref_avg)/ref_avg).flux.value * ref_avg.meta['WTTSYS'] * u.K
+                ta[i]._data = ((sig_avg - ref_avg) / ref_avg).flux.value * ref_avg.meta["WTTSYS"] * u.K
                 # TUNIT7 is fragile as locations of specific header data could change in the future.
                 ta[i].meta["TUNIT7"] = "Ta"
-                ta[i].meta["TSYS"] = ref_avg.meta['WTTSYS']
-                
+                ta[i].meta["TSYS"] = ref_avg.meta["WTTSYS"]
+
                 # Add to the average, a-la accum.
                 # @TODO possibly replace with a call to util.sq_weighted_avg
-                wt_avg += ta[i].meta["TSYS"]**-2.
-                ta_avg[:] += ta[i].flux.value * ta[i].meta["TSYS"]**-2.
+                wt_avg += ta[i].meta["TSYS"] ** -2.0
+                ta_avg[:] += ta[i].flux.value * ta[i].meta["TSYS"] ** -2.0
                 tsys_wt_ = tsys_weight(ta[i].meta["EXPOSURE"], ta[i].meta["CDELT1"], ta[i].meta["TSYS"])
                 tsys_wt += tsys_wt_
                 tsys_avg += ta[i].meta["TSYS"] * tsys_wt_
@@ -476,45 +493,68 @@ def subbeamnod(self,scan,bintable=0,**kwargs):
             data._data = ta_avg
             data.meta["TSYS"] = tsys_avg
             data.meta["EXPOSURE"] = exposure
-           
+
             return data
 
-        elif method == 'scan':
+        elif method == "scan":
             # Process the whole scan as a single block.
-            # This is less accurate, but might be needed if 
+            # This is less accurate, but might be needed if
             # the scan was aborted and there are not enough
             # sig/ref cycles to do a per cycle calibration.
 
-            tpon  = self.gettp(scan,sig=None,cal=None,
-                               bintable=bintable,fdnum=fdnum,
-                               plnum=plnum,ifnum=ifnum,
-                               subref=-1,weight=w,calibrate=docal)
-            tpoff = self.gettp(scan,sig=None,cal=None,
-                               bintable=bintable,fdnum=fdnum,
-                               plnum=plnum,ifnum=ifnum,subref=1,
-                               weight=w,calibrate=docal)
-            
-            on  =  tpon.timeaverage(weights=w)
+            tpon = self.gettp(
+                scan,
+                sig=None,
+                cal=None,
+                bintable=bintable,
+                fdnum=fdnum,
+                plnum=plnum,
+                ifnum=ifnum,
+                subref=-1,
+                weight=w,
+                calibrate=docal,
+            )
+            tpoff = self.gettp(
+                scan,
+                sig=None,
+                cal=None,
+                bintable=bintable,
+                fdnum=fdnum,
+                plnum=plnum,
+                ifnum=ifnum,
+                subref=1,
+                weight=w,
+                calibrate=docal,
+            )
+
+            on = tpon.timeaverage(weights=w)
             off = tpoff.timeaverage(weights=w)
-            
+
             # in order to reproduce gbtidl tsys, we need to do a normal
             # total power scan
-            fulltp = self.gettp(scan,sig=None,cal=None,
-                            bintable=bintable,fdnum=fdnum,
-                            plnum=plnum,ifnum=ifnum,
-                            weight=w,calibrate=docal).timeaverage(weights=w)
-            tsys = fulltp.meta['TSYS'] 
-            data = tsys*(on - off)/off
-            data.meta['MEANTSYS'] = 0.5*np.mean((on.meta['TSYS']+off.meta['TSYS']))
-            data.meta['WTTSYS'] = tsys
-            data.meta['TSYS'] = data.meta['WTTSYS']
-            #if kwargs_opts['debug']:
+            fulltp = self.gettp(
+                scan,
+                sig=None,
+                cal=None,
+                bintable=bintable,
+                fdnum=fdnum,
+                plnum=plnum,
+                ifnum=ifnum,
+                weight=w,
+                calibrate=docal,
+            ).timeaverage(weights=w)
+            tsys = fulltp.meta["TSYS"]
+            data = tsys * (on - off) / off
+            data.meta["MEANTSYS"] = 0.5 * np.mean((on.meta["TSYS"] + off.meta["TSYS"]))
+            data.meta["WTTSYS"] = tsys
+            data.meta["TSYS"] = data.meta["WTTSYS"]
+            # if kwargs_opts['debug']:
             #    data._on = tpon
             #    data._off = tpoff
             return data
 
-    def onoff_scan_list(self,scans=None,ifnum=0,plnum=0,bintable=0):
-        """Get the scan row indices for position-switch data sorted 
+    def onoff_scan_list(self, scans=None, ifnum=0, plnum=0, bintable=0):
+        """Get the scan row indices for position-switch data sorted
            by ON and OFF state
 
         Parameters
@@ -534,68 +574,74 @@ def onoff_scan_list(self,scans=None,ifnum=0,plnum=0,bintable=0):
                 A dictionary with keys 'ON' and 'OFF' giving the row indices of ON and OFF data for the input scan(s)
         """
         self._create_index_if_needed()
-        #print(f"onoff_scan_list(scans={scans},if={ifnum},pl={plnum})")
-        s = {"ON": [], "OFF" :[]}
+        # print(f"onoff_scan_list(scans={scans},if={ifnum},pl={plnum})")
+        s = {"ON": [], "OFF": []}
         if type(scans) == int:
             scans = [scans]
-        if False: # this does all bintables.
+        if False:  # this does all bintables.
             for df in self._ptable:
-                #OnOff lowest scan number is on
-                #dfonoff = self.select(df,"PROC","OnOff"))
-                #OffOn lowest scan number is off
-                #dfoffon = self.select(df,"PROC","OffOn"))
-                dfon  = self.select("_OBSTYPE","PSWITCHON",df)
-                dfoff = self.select("_OBSTYPE","PSWITCHOFF",df)
+                # OnOff lowest scan number is on
+                # dfonoff = self.select(df,"PROC","OnOff"))
+                # OffOn lowest scan number is off
+                # dfoffon = self.select(df,"PROC","OffOn"))
+                dfon = self.select("_OBSTYPE", "PSWITCHON", df)
+                dfoff = self.select("_OBSTYPE", "PSWITCHOFF", df)
                 onscans = uniq(list(dfon["SCAN"]))
-                #print("ON: ",onscans)
+                # print("ON: ",onscans)
                 s["ON"].extend(onscans)
                 offscans = uniq(list(dfoff["SCAN"]))
-                #print("OFF: ",offscans)
+                # print("OFF: ",offscans)
                 s["OFF"].extend(offscans)
 
-        df    = self._ptable[bintable]
+        df = self._ptable[bintable]
         df = df[(df["PLNUM"] == plnum) & (df["IFNUM"] == ifnum)]
-        dfon  = self.select("_OBSTYPE","PSWITCHON",df)
-        dfoff = self.select("_OBSTYPE","PSWITCHOFF",df)
-        onscans = uniq(list(dfon["SCAN"])) # wouldn't set() do this too?
+        dfon = self.select("_OBSTYPE", "PSWITCHON", df)
+        dfoff = self.select("_OBSTYPE", "PSWITCHOFF", df)
+        onscans = uniq(list(dfon["SCAN"]))  # wouldn't set() do this too?
         offscans = uniq(list(dfoff["SCAN"]))
         if scans is not None:
-        # The companion scan will always be +/- 1 depending if procseqn is 1(ON) or 2(OFF)
-        # First check the requested scan number(s) are even in the ONs or OFFs of this bintable
+            # The companion scan will always be +/- 1 depending if procseqn is 1(ON) or 2(OFF)
+            # First check the requested scan number(s) are even in the ONs or OFFs of this bintable
             seton = set(onscans)
             setoff = set(offscans)
             onrequested = seton.intersection(scans)
-            #print("ON REQUESTED ",onrequested)
+            # print("ON REQUESTED ",onrequested)
             offrequested = setoff.intersection(scans)
-            #print("OFF REQUESTED ",offrequested)
+            # print("OFF REQUESTED ",offrequested)
             if len(onrequested) == 0 and len(offrequested) == 0:
                 raise ValueError(f"Scans {scans} not found in ONs or OFFs of bintable {bintable}")
-        # Then check that for each requested ON/OFF there is a matching OFF/ON
-        # and build the final matched list of ONs and OFfs.
+            # Then check that for each requested ON/OFF there is a matching OFF/ON
+            # and build the final matched list of ONs and OFfs.
             sons = list(onrequested.copy())
             soffs = list(offrequested.copy())
             missingoff = []
             missingon = []
             for i in onrequested:
-                expectedoff = i+1
-                #print(f"DOING ONQUESTED {i}, looking for off {expectedoff}")
+                expectedoff = i + 1
+                # print(f"DOING ONQUESTED {i}, looking for off {expectedoff}")
                 if len(setoff.intersection([expectedoff])) == 0:
                     missingoff.append(expectedoff)
                 else:
                     soffs.append(expectedoff)
             for i in offrequested:
-                expectedon = i-1
-                #print(f"DOING OFFEQUESTED {i}, looking for on {expectedon}")
+                expectedon = i - 1
+                # print(f"DOING OFFEQUESTED {i}, looking for on {expectedon}")
                 if len(seton.intersection([expectedon])) == 0:
                     missingon.append(expectedon)
                 else:
                     sons.append(expectedon)
             if len(missingoff) > 0:
-                raise ValueError(f"For the requested ON scans {onrequested}, the OFF scans {missingoff} were not present in bintable {bintable}")
+                raise ValueError(
+                    f"For the requested ON scans {onrequested}, the OFF scans {missingoff} were not present in bintable"
+                    f" {bintable}"
+                )
             if len(missingon) > 0:
-                raise ValueError(f"For the requested OFF scans {offrequested}, the ON scans {missingon} were not present in bintable {bintable}")
-            #print("ON",sorted(sons))
-            #print("OFF",sorted(soffs))
+                raise ValueError(
+                    f"For the requested OFF scans {offrequested}, the ON scans {missingon} were not present in bintable"
+                    f" {bintable}"
+                )
+            # print("ON",sorted(sons))
+            # print("OFF",sorted(soffs))
             s["ON"] = sorted(set(sons))
             s["OFF"] = sorted(set(soffs))
         else:
@@ -604,9 +650,9 @@ def onoff_scan_list(self,scans=None,ifnum=0,plnum=0,bintable=0):
 
         return s
 
-    def calonoff_rows(self,scans=None,bintable=0,**kwargs):
+    def calonoff_rows(self, scans=None, bintable=0, **kwargs):
         """Get individual scan row numbers  sorted by whether the calibration (diode) was on or off, and selected by ifnum,plnum, fdnum,subref,bintable.
-        
+
         Parameters
         ----------
             scans : int or list-like
@@ -628,37 +674,37 @@ def calonoff_rows(self,scans=None,bintable=0,**kwargs):
                 A dictionary with keys 'ON' and 'OFF' giving the row indices of CALON and CALOFF data for the input scan(s)
         """
         self._create_index_if_needed()
-        s = {"ON": [], "OFF" :[]}
-        ifnum  = kwargs.get('ifnum',None)
-        plnum  = kwargs.get('plnum',None)
-        fdnum  = kwargs.get('fdnum',None)
-        subref = kwargs.get('subref',None)
+        s = {"ON": [], "OFF": []}
+        ifnum = kwargs.get("ifnum", None)
+        plnum = kwargs.get("plnum", None)
+        fdnum = kwargs.get("fdnum", None)
+        subref = kwargs.get("subref", None)
         if type(scans) == int:
             scans = [scans]
-        df    = self._ptable[bintable]
+        df = self._ptable[bintable]
         if scans is not None:
             df = df[df["SCAN"].isin(scans)]
-        dfon  = self.select("CAL","T",df)
-        dfoff = self.select("CAL","F",df)
+        dfon = self.select("CAL", "T", df)
+        dfoff = self.select("CAL", "F", df)
         if ifnum is not None:
-            dfon  = self.select("IFNUM",ifnum,dfon)
-            dfoff  = self.select("IFNUM",ifnum,dfoff)
+            dfon = self.select("IFNUM", ifnum, dfon)
+            dfoff = self.select("IFNUM", ifnum, dfoff)
         if plnum is not None:
-            dfon  = self.select("PLNUM",plnum,dfon)
-            dfoff  = self.select("PLNUM",plnum,dfoff)
+            dfon = self.select("PLNUM", plnum, dfon)
+            dfoff = self.select("PLNUM", plnum, dfoff)
         if fdnum is not None:
-            dfon  = self.select("FDNUM",fdnum,dfon)
-            dfoff  = self.select("FDNUM",fdnum,dfoff)
+            dfon = self.select("FDNUM", fdnum, dfon)
+            dfoff = self.select("FDNUM", fdnum, dfoff)
         if subref is not None:
-            dfon  = self.select("SUBREF_STATE",subref,dfon)
-            dfoff  = self.select("SUBREF_STATE",subref,dfoff)
-        s["ON"]  = list(dfon.index)
+            dfon = self.select("SUBREF_STATE", subref, dfon)
+            dfoff = self.select("SUBREF_STATE", subref, dfoff)
+        s["ON"] = list(dfon.index)
         s["OFF"] = list(dfoff.index)
         return s
 
-    def onoff_rows(self,scans=None,ifnum=0,plnum=0,bintable=0): 
+    def onoff_rows(self, scans=None, ifnum=0, plnum=0, bintable=0):
         """get individual ON/OFF (position switch) scan row numbers selected by ifnum,plnum, bintable.
-        
+
         Parameters
         ----------
             scans : int or list-like
@@ -675,23 +721,23 @@ def onoff_rows(self,scans=None,ifnum=0,plnum=0,bintable=0):
             rows : dict
                 A dictionary with keys 'ON' and 'OFF' giving the row indices of the ON and OFF data for the input scan(s)
         """
-    #@TODO deal with mulitple bintables
-    #@TODO rename this sigref_rows?
-    # keep the bintable keyword and allow iteration over bintables if requested (bintable=None) 
-        #print(f"onoff_rows(scans={scans},if={ifnum},pl={plnum})")
+        # @TODO deal with mulitple bintables
+        # @TODO rename this sigref_rows?
+        # keep the bintable keyword and allow iteration over bintables if requested (bintable=None)
+        # print(f"onoff_rows(scans={scans},if={ifnum},pl={plnum})")
         self._create_index_if_needed()
-        rows = {"ON": [], "OFF" :[]}
+        rows = {"ON": [], "OFF": []}
         if type(scans) is int:
             scans = [scans]
-        scans = self.onoff_scan_list(scans,ifnum,plnum,bintable)
-        #scans is now a dict of "ON" "OFF
-        for key in scans: 
-            rows[key] = self.scan_rows(scans[key],ifnum,plnum,bintable)
+        scans = self.onoff_scan_list(scans, ifnum, plnum, bintable)
+        # scans is now a dict of "ON" "OFF
+        for key in scans:
+            rows[key] = self.scan_rows(scans[key], ifnum, plnum, bintable)
         return rows
-        
-    def scan_rows(self,scans,ifnum=0,plnum=0,bintable=0):
+
+    def scan_rows(self, scans, ifnum=0, plnum=0, bintable=0):
         """get scan rows selected by ifnum,plnum, bintable.
-        
+
         Parameters
         ----------
             scans : int or list-like
@@ -708,8 +754,8 @@ def scan_rows(self,scans,ifnum=0,plnum=0,bintable=0):
             rows : list
                 Lists of the rows in each bintable that contain the scans. Index of `rows` is the bintable index number
         """
-        #scans is a list
-        #print(f"scan_rows(scans={scans},if={ifnum},pl={plnum})")
+        # scans is a list
+        # print(f"scan_rows(scans={scans},if={ifnum},pl={plnum})")
         self._create_index_if_needed()
         if scans is None:
             raise ValueError("Parameter 'scans' cannot be None. It must be int or list of int")
@@ -720,9 +766,9 @@ def scan_rows(self,scans,ifnum=0,plnum=0,bintable=0):
             raise Exception(f"Scans {scans} not found in bintable {bintable}")
         return rows
 
-    def _scan_rows_all(self,scans):
+    def _scan_rows_all(self, scans):
         """get scan rows regardless of ifnum,plnum, bintable.
-        
+
         Parameters
         ----------
             scans : int or list-like
@@ -743,7 +789,7 @@ def _scan_rows_all(self,scans):
             rows.append(list(df.index))
         return rows
 
-    def write_scans(self,fileobj,scans,output_verify="exception",overwrite=False,checksum=False):
+    def write_scans(self, fileobj, scans, output_verify="exception", overwrite=False, checksum=False):
         """
         Write specific scans of the `GBTFITSLoad` to a new file.
 
@@ -754,7 +800,7 @@ def write_scans(self,fileobj,scans,output_verify="exception",overwrite=False,che
             writeable mode.
 
         scans: int or list-like
-            Range of scans to write out. e.g. 0, [14,25,32]. 
+            Range of scans to write out. e.g. 0, [14,25,32].
 
         output_verify : str
             Output verification option.  Must be one of ``"fix"``,
@@ -774,18 +820,16 @@ def write_scans(self,fileobj,scans,output_verify="exception",overwrite=False,che
         """
         # get the rows that contain the scans in all bintables
         rows = self._scan_rows_all(scans)
-        #print("Using rows",rows)
+        # print("Using rows",rows)
         hdu0 = self._hdu[0].copy()
         outhdu = fits.HDUList(hdu0)
         # get the bintables rows as new bintables.
         for i in range(len(rows)):
-            ob = self._bintable_from_rows(rows[i],i)
-            #print(f"bintable {i} #rows {len(rows[i])} data length {len(ob.data)}")
+            ob = self._bintable_from_rows(rows[i], i)
+            # print(f"bintable {i} #rows {len(rows[i])} data length {len(ob.data)}")
             if len(ob.data) > 0:
                 outhdu.append(ob)
-        #print(outhdu.info())
+        # print(outhdu.info())
         # write it out!
-        outhdu.update_extend() # possibly unneeded
-        outhdu.writeto(fileobj,
-            output_verify=output_verify,
-            overwrite=overwrite, checksum=checksum)
+        outhdu.update_extend()  # possibly unneeded
+        outhdu.writeto(fileobj, output_verify=output_verify, overwrite=overwrite, checksum=checksum)
diff --git a/src/dysh/fits/sdfitsload.py b/src/dysh/fits/sdfitsload.py
index cb4f2342..40752fc5 100644
--- a/src/dysh/fits/sdfitsload.py
+++ b/src/dysh/fits/sdfitsload.py
@@ -2,60 +2,59 @@
     - Not typically used directly.  Sub-class for specific telescope SDFITS flavors.
 """
 import sys
-import copy
-from astropy.wcs import WCS
-from astropy.units import cds
-from astropy.io import fits
-from astropy.modeling import models, fitting
+
 import astropy.units as u
-from astropy.table import Table
-import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
+from astropy.io import fits
+from astropy.table import Table
+from astropy.units import cds
+from astropy.wcs import WCS
 
-from ..spectra.spectrum import Spectrum
-from ..spectra.obsblock import Obsblock
 from ..spectra import veldef_to_convention
-from ..util import uniq, stripTable
-#from .. import version
+from ..spectra.obsblock import Obsblock
+from ..spectra.spectrum import Spectrum
+from ..util import stripTable, uniq
+
+# from .. import version
 
 
 class SDFITSLoad(object):
-    '''
+    """
     Generic Container for a bintable(s) from selected HDU(s)
 
     Parameters
     ----------
-        filename : str 
+        filename : str
             input file name
         source  : str
             target source to select from input file. Default: all sources
         hdu : int or list
             Header Data Unit to select from input file. Default: all HDUs
-    '''
+    """
+
     def __init__(self, filename, source=None, hdu=None, **kwargs):
-        if kwargs.get("verbose",None):
+        if kwargs.get("verbose", None):
             print("==SDFITSLoad %s" % filename)
         cds.enable()  # to get mmHg
-        kwargs_opts = {'fix':False}
-        kwargs_opts = {'wcs':False}
+        kwargs_opts = {"fix": False}
+        kwargs_opts = {"wcs": False}
         kwargs_opts.update(kwargs)
         self._filename = filename
         self._bintable = []
         self._ptable = []
         self._binheader = []
         self._data = []
-        self._hdu = fits.open(filename)  
+        self._hdu = fits.open(filename)
         self._header = self._hdu[0].header
-        self.load(hdu,**kwargs_opts)
+        self.load(hdu, **kwargs_opts)
         self.create_index()
-        #self._hdu.close()  # can't access hdu[i].data member of you do this.
+        # self._hdu.close()  # can't access hdu[i].data member of you do this.
 
     def info(self):
         """Return the `~astropy.HDUList` info()"""
         return self._hdu.info()
 
-    @property 
+    @property
     def bintable(self):
         """The list of bintables"""
         return self._bintable
@@ -64,28 +63,28 @@ def binheader(self):
         """The list of bintable headers"""
         return self._binheader
 
-    @property 
+    @property
     def filename(self):
         """The input SDFITS filename"""
         return self._filename
-    
-    def index(self,hdu):
+
+    def index(self, hdu):
         """The index table"""
         return self._ptable[hdu]
 
-    def reset(self,hdu=None):
+    def reset(self, hdu=None):
         """Reset all attributes"""
         self._bintable = []
         self._binheader = []
         self._ptable = []
         self._data = []
         self._spectra = []
-        self._hdu = fits.open(self._filename)  
+        self._hdu = fits.open(self._filename)
         self._header = self._hdu[0].header
-        #if hdu is not None:
-         #   self.load(src,hdu)
-    
-    def create_index(self,hdu=None):
+        # if hdu is not None:
+        #   self.load(src,hdu)
+
+    def create_index(self, hdu=None):
         """Create the index of the SDFITS file.
 
         Parameters
@@ -96,15 +95,15 @@ def create_index(self,hdu=None):
         if hdu is not None:
             ldu = list([hdu])
         else:
-            ldu = range(1,len(self._hdu))
+            ldu = range(1, len(self._hdu))
         self._ptable = []
         for i in ldu:
-            t = Table.read(self._hdu[i]) 
-            t.remove_column('DATA')
+            t = Table.read(self._hdu[i])
+            t.remove_column("DATA")
             stripTable(t)
             self._ptable.append(t.to_pandas())
             del t
-            
+
     def load(self, hdu=None, **kwargs):
         """
         Load the bintable for given hdu.
@@ -120,23 +119,23 @@ def load(self, hdu=None, **kwargs):
         self._binheader = []
         self._data = []
         self._nrows = []
-        source = kwargs.get('source',None)
-        fix = kwargs.get('fix',False)
-        wcs = kwargs.get('wcs',False)
+        kwargs.get("source", None)
+        kwargs.get("fix", False)
+        kwargs.get("wcs", False)
 
         if hdu is not None:
             ldu = list([hdu])
         else:
-            ldu = range(1,len(self._hdu))
+            ldu = range(1, len(self._hdu))
         for i in ldu:
-            j=i-1
-            self._bintable.append(self._hdu[i]) 
+            j = i - 1
+            self._bintable.append(self._hdu[i])
             self._binheader.append(self._hdu[i].header)
             # TODO: don't allow preselection here, it just screws bookkeepingu p.
             # All selection must happen in obsblocks.
-            #if source is None:
-            #self._data.append(self._bintable[j].data[:]["DATA"])
-            #else:
+            # if source is None:
+            # self._data.append(self._bintable[j].data[:]["DATA"])
+            # else:
             #    wh1 = np.char.strip(self._bintable[j]['OBJECT']) == source # true/false array
             #    if wh1.sum() == 0: #all False none found
             #        srcs = np.unique(self._bintable[j]['OBJECT'])
@@ -146,106 +145,132 @@ def load(self, hdu=None, **kwargs):
             #    self._bintable[j] = self._bintable[j][mask]  # header will be wrong?
             self._nrows.append(self._binheader[j]["NAXIS2"])
 
-        if kwargs.get("index",False):
+        if kwargs.get("index", False):
             self.create_index(hdu)
 
-    def _loadlists(self,hdu,fix=False,wcs=False,maxspect=1E16):
-        '''Create an obsblock from all rows in bintable.  For debug/performance testing only'''
+    def _loadlists(self, hdu, fix=False, wcs=False, maxspect=1e16):
+        """Create an obsblock from all rows in bintable.  For debug/performance testing only"""
         self._obsblock = []
-        i=0
+        i = 0
         k = -1
-        print("HDU = ",hdu)
+        print("HDU = ", hdu)
         if hdu is not None:
-            b = self._ptable[hdu-1]
+            b = self._ptable[hdu - 1]
             rawspect = self._bintable[i].data["DATA"]
             sl = SpectrumList()
-            maxload = int(np.min([maxspect,self.nrows(i)]))
-            print(f"Creating {maxload} Spectrum in bintable {i} HDU {hdu}",file=sys.stderr)
+            maxload = int(np.min([maxspect, self.nrows(i)]))
+            print(f"Creating {maxload} Spectrum in bintable {i} HDU {hdu}", file=sys.stderr)
             for j in range(maxload):
-                k = k+1
+                k = k + 1
                 # need extra [[]] because we have 1x1 spatial NAXIS
                 # otherwise, slicing the spectrum won't work.
-                if wcs: 
-                    sp = np.array([[self.rawspectrum(i,j)]])
+                if wcs:
+                    sp = np.array([[self.rawspectrum(i, j)]])
                 else:
-                    #sp = self.rawspectrum(i,j)*u.K
-                    sp = np.copy(rawspect[j])#*u.K
-                    #sp = np.random.rand(32768)*u.K
-                naxis1 =  sp.shape[0]#self.nchan(i)
-                printme = int(0.1*len(b))
-                if (k%printme) == 0: 
+                    # sp = self.rawspectrum(i,j)*u.K
+                    sp = np.copy(rawspect[j])  # *u.K
+                    # sp = np.random.rand(32768)*u.K
+                naxis1 = sp.shape[0]  # self.nchan(i)
+                printme = int(0.1 * len(b))
+                if (k % printme) == 0:
                     print(f"Row {k} nchan {naxis1} {type(sp)}", file=sys.stderr)
-                    #print(f"NAXIS1 is {naxis1}",file=sys.stderr)
-                crval1  = b['CRVAL1'][j]
-                cdelt1  = b['CDELT1'][j]
-                crpix1  = b['CRPIX1'][j]
-                ctype1  = b['CTYPE1'][j]
+                    # print(f"NAXIS1 is {naxis1}",file=sys.stderr)
+                crval1 = b["CRVAL1"][j]
+                cdelt1 = b["CDELT1"][j]
+                crpix1 = b["CRPIX1"][j]
+                b["CTYPE1"][j]
                 # Ensure rest frequency is in Hertz
                 # CUNIT1 is not always present
-                restfrq = b['RESTFREQ'][j]
+                restfrq = b["RESTFREQ"][j]
                 if "CUNIT1" in b.columns:
-                    cunit1  = b['CUNIT1'][j]
+                    cunit1 = b["CUNIT1"][j]
                     rfq = restfrq * u.Unit(cunit1)
-                    restfreq = rfq.to("Hz").value
+                    rfq.to("Hz").value
                 cunit1 = "Hz"
-                crval2  = b['CRVAL2'][j]
-                crval3  = b['CRVAL3'][j]
-                ctype2  = b['CTYPE2'][j]
-                ctype3  = b['CTYPE3'][j]
+                crval2 = b["CRVAL2"][j]
+                crval3 = b["CRVAL3"][j]
+                ctype2 = b["CTYPE2"][j]
+                ctype3 = b["CTYPE3"][j]
                 # 'FREQ-OBS' to 'FREQ'; assuming SPECSYS='TOPOCENT'
-                #if ctype1 == 'FREQ-OBS': ctype1  = 'FREQ'
+                # if ctype1 == 'FREQ-OBS': ctype1  = 'FREQ'
                 # only axis1 needs a full description, axis2,3,4 are all single points
                 if wcs:
-                    wcs = WCS(header={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfrq,
-                                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1
-                                     },
-                             fix=fix)
+                    wcs = WCS(
+                        header={
+                            "CDELT1": cdelt1,
+                            "CRVAL1": crval1,
+                            "CUNIT1": cunit1,
+                            "CTYPE1": "FREQ",
+                            "CRPIX1": crpix1,
+                            "RESTFRQ": restfrq,
+                            "CTYPE2": ctype2,
+                            "CRVAL2": crval2,
+                            "CRPIX2": 1,
+                            "CTYPE3": ctype3,
+                            "CRVAL3": crval3,
+                            "CRPIX3": 1,
+                            "CUNIT2": "deg",
+                            "CUNIT3": "deg",
+                            "NAXIS1": naxis1,
+                            "NAXIS2": 1,
+                            "NAXIS3": 1,
+                        },
+                        fix=fix,
+                    )
                 else:
                     wcs = None
                 # GBT really fucks up FREQ/VELDEF/VELFRAME
-                #if False:
+                # if False:
                 if "VELFRAME" in b.columns:
-                    vframe = b['VELFRAME'][j]
+                    vframe = b["VELFRAME"][j]
                 elif "VFRAME" in b.columns:
-                    vframe = b['VFRAME'][j]
+                    vframe = b["VFRAME"][j]
                 else:
                     vframe = None
                 if "VELDEF" in b.columns:
-                    vdef = b['VELDEF'][j]
+                    vdef = b["VELDEF"][j]
                 else:
                     vdef = None
 
-                meta={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfrq,
-                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1,
-                      'VELDEF': vdef, 'VELFRAME': vframe
-                     }
-
-                convention = self.velocity_convention(vdef,vframe)
-                #meta = dict(b.loc[j])# Necessary? Since we are sending whole pandas table to Obsblock
+                meta = {
+                    "CDELT1": cdelt1,
+                    "CRVAL1": crval1,
+                    "CUNIT1": cunit1,
+                    "CTYPE1": "FREQ",
+                    "CRPIX1": crpix1,
+                    "RESTFRQ": restfrq,
+                    "CTYPE2": ctype2,
+                    "CRVAL2": crval2,
+                    "CRPIX2": 1,
+                    "CTYPE3": ctype3,
+                    "CRVAL3": crval3,
+                    "CRPIX3": 1,
+                    "CUNIT2": "deg",
+                    "CUNIT3": "deg",
+                    "NAXIS1": naxis1,
+                    "NAXIS2": 1,
+                    "NAXIS3": 1,
+                    "VELDEF": vdef,
+                    "VELFRAME": vframe,
+                }
+
+                convention = self.velocity_convention(vdef, vframe)
+                # meta = dict(b.loc[j])# Necessary? Since we are sending whole pandas table to Obsblock
                 if fix:
                     self.fix_meta(meta)
                 if False:
                     try:
-                        convention = self.velocity_convention(meta['VELDEF'],meta['VELFRAME'])
+                        convention = self.velocity_convention(meta["VELDEF"], meta["VELFRAME"])
                     except Exception:
-                        #print("WARNING: insufficient veldef/velframe, assuming convention is 'doppler_radio'")
-                        convention="doppler_radio"
+                        # print("WARNING: insufficient veldef/velframe, assuming convention is 'doppler_radio'")
+                        convention = "doppler_radio"
                 meta = {}
-                sl.append(Spectrum(flux=sp*u.K,wcs=wcs,  meta=meta, velocity_convention=convention))
-            self._obsblock.append(Obsblock(sl,self._ptable[i]))
-            i=i+1
-
+                sl.append(Spectrum(flux=sp * u.K, wcs=wcs, meta=meta, velocity_convention=convention))
+            self._obsblock.append(Obsblock(sl, self._ptable[i]))
+            i = i + 1
 
-    def fix_meta(self,meta):
-        """Do any repair to the meta/header for peculariaties in definitions 
+    def fix_meta(self, meta):
+        """Do any repair to the meta/header for peculariaties in definitions
         from a particular observatory
         The passed-in dictionary will be repaired in place.
         At minimum this method must populate meta['VELDEF'] and meta['VELFRAME']
@@ -256,25 +281,25 @@ def fix_meta(self,meta):
                 The header of the `~Spectrum` to be fixed, corresponding to the `meta` attribute of the Spectrum.
         """
         pass
-    
-    def velocity_convention(self,veldef,velframe):
-        '''Compute the velocity convention string use for velocity conversions, 
-        given the VELDEF and VELFRAME values. 
+
+    def velocity_convention(self, veldef, velframe):
+        """Compute the velocity convention string use for velocity conversions,
+        given the VELDEF and VELFRAME values.
         Return value must be a recognized string of `~specutils.Spectrum1D`, one of
         {"doppler_relativistic", "doppler_optical", "doppler_radio"}
-        Sub-classes should implement, because different observatories use VELDEF and 
+        Sub-classes should implement, because different observatories use VELDEF and
         VELFRAME inconsistently. This base class method hard-coded to return "doppler_radio."
-            
+
         Parameters
         ----------
             veldef : str
                 The velocity definition string (`VELDEF` FITS keyword)
             velframe : str
                 The velocity frame string (`VELFRAME` FITS keyword)
-        '''
+        """
         return "doppler_radio"
-    
-    def udata(self,bintable,key):
+
+    def udata(self, bintable, key):
         """The unique list of values of a given header keyword
 
         Parameters
@@ -289,8 +314,8 @@ def udata(self,bintable,key):
                 The unique set of values for the input keyword.
         """
         return uniq(self._ptable[bintable][key])
-                                  
-    def ushow(self,bintable,key):
+
+    def ushow(self, bintable, key):
         """Print the unique list of values of a given header keyword
 
         Parameters
@@ -300,10 +325,10 @@ def ushow(self,bintable,key):
             key : str
                 The keyword to retrieve
         """
-        print(f'{bintable} {key}: {self.udata(bintable,key)}')
-        
-    def naxis(self,bintable,naxis):
-        '''The NAXISn value of the input bintable.
+        print(f"{bintable} {key}: {self.udata(bintable,key)}")
+
+    def naxis(self, bintable, naxis):
+        """The NAXISn value of the input bintable.
 
         Parameters
         ----------
@@ -315,12 +340,12 @@ def naxis(self,bintable,naxis):
         Returns
         -------
             naxis : the length of the NAXIS
-        '''
-        nax = f'NAXIS{naxis}'
+        """
+        nax = f"NAXIS{naxis}"
         return self._binheader[bintable][nax]
-    
-    def nintegrations(self,bintable,source=None):
-        '''The number of integrations on a given source divided by the number of polarizations
+
+    def nintegrations(self, bintable, source=None):
+        """The number of integrations on a given source divided by the number of polarizations
 
         Parameters
         ----------
@@ -331,22 +356,22 @@ def nintegrations(self,bintable,source=None):
 
         Returns
         -------
-            nintegrations : the number of integrations 
-        '''
-        
-        data = self.rawspectra(bintable)
+            nintegrations : the number of integrations
+        """
+
+        self.rawspectra(bintable)
         if source is not None:
-            df = self.select('OBJECT',source,self._ptable[bintable])
-            #nfeed = df["FEED"].nunique()
+            df = self.select("OBJECT", source, self._ptable[bintable])
+            # nfeed = df["FEED"].nunique()
             numsources = len(df)
-            #nint = numsources//(self.npol(bintable)*nfeed)
-            nint = numsources//self.npol(bintable)
+            # nint = numsources//(self.npol(bintable)*nfeed)
+            nint = numsources // self.npol(bintable)
         else:
-            nint = self.nrows(bintable)//self.npol(bintable)
+            nint = self.nrows(bintable) // self.npol(bintable)
         return nint
 
-    def rawspectra(self,bintable):
-        '''Get the raw (unprocessed) spectra from the input bintable.
+    def rawspectra(self, bintable):
+        """Get the raw (unprocessed) spectra from the input bintable.
 
         Parameters
         ----------
@@ -357,68 +382,80 @@ def rawspectra(self,bintable):
         -------
             rawspectra : ~numpy.ndarray
                 The DATA column of the input bintable
-        '''
+        """
         return self._bintable[bintable].data[:]["DATA"]
 
-    def rawspectrum(self,bintable,i):
-        '''Get a single raw (unprocessed) spectrum from the input bintable.
-    TODO: arguments are backwards from getrow(), getspec()
-
-        Parameters
-        ----------
-            bintable :  int
-                The index of the `bintable` attribute
-            i :  int
-                The row index to retrieve
-
-        Returns
-        -------
-            rawspectrum : ~numpy.ndarray
-                The i-th row of DATA column of the input bintable
-        '''
+    def rawspectrum(self, bintable, i):
+        """Get a single raw (unprocessed) spectrum from the input bintable.
+        TODO: arguments are backwards from getrow(), getspec()
+
+            Parameters
+            ----------
+                bintable :  int
+                    The index of the `bintable` attribute
+                i :  int
+                    The row index to retrieve
+
+            Returns
+            -------
+                rawspectrum : ~numpy.ndarray
+                    The i-th row of DATA column of the input bintable
+        """
         return self._bintable[bintable].data[:]["DATA"][i]
 
-    def getrow(self,i,bintable=0):
+    def getrow(self, i, bintable=0):
         return self._bintable[bintable].data[i]
 
-    def getspec(self,i,bintable=0):
+    def getspec(self, i, bintable=0):
         """get a row (record) as a Spectrum"""
         meta = self._ptable[bintable].iloc[i]
-        data = self.rawspectrum(bintable,i)
+        data = self.rawspectrum(bintable, i)
         naxis1 = len(data)
-        ctype1 = meta['CTYPE1']
-        ctype2 = meta['CTYPE2']
-        ctype3 = meta['CTYPE3']
-        crval1 = meta['CRVAL1']
-        crval2 = meta['CRVAL2']
-        crval3 = meta['CRVAL3']
-        crpix1 = meta['CRPIX1']
-        cdelt1 = meta['CDELT1']
-        restfrq = meta['RESTFREQ']
-        if 'CUNIT1' in meta:
-            cunit1 = meta['CUNIT1']
+        meta["CTYPE1"]
+        ctype2 = meta["CTYPE2"]
+        ctype3 = meta["CTYPE3"]
+        crval1 = meta["CRVAL1"]
+        crval2 = meta["CRVAL2"]
+        crval3 = meta["CRVAL3"]
+        crpix1 = meta["CRPIX1"]
+        cdelt1 = meta["CDELT1"]
+        restfrq = meta["RESTFREQ"]
+        if "CUNIT1" in meta:
+            cunit1 = meta["CUNIT1"]
         else:
-            cunit1 = "Hz" #@TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
+            cunit1 = "Hz"  # @TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
         rfq = restfrq * u.Unit(cunit1)
         restfreq = rfq.to("Hz").value
 
-        #@TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
-        wcs = WCS(header={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfreq,
-                                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1
-                                     },
-                             )
-        vc = veldef_to_convention(meta['VELDEF'])
-        
+        # @TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
+        wcs = WCS(
+            header={
+                "CDELT1": cdelt1,
+                "CRVAL1": crval1,
+                "CUNIT1": cunit1,
+                "CTYPE1": "FREQ",
+                "CRPIX1": crpix1,
+                "RESTFRQ": restfreq,
+                "CTYPE2": ctype2,
+                "CRVAL2": crval2,
+                "CRPIX2": 1,
+                "CTYPE3": ctype3,
+                "CRVAL3": crval3,
+                "CRPIX3": 1,
+                "CUNIT2": "deg",
+                "CUNIT3": "deg",
+                "NAXIS1": naxis1,
+                "NAXIS2": 1,
+                "NAXIS3": 1,
+            },
+        )
+        vc = veldef_to_convention(meta["VELDEF"])
+
         # raw data are in counts
-        return Spectrum(data*u.count,wcs=wcs,meta=meta.to_dict(),velocity_convention=vc)
+        return Spectrum(data * u.count, wcs=wcs, meta=meta.to_dict(), velocity_convention=vc)
 
-    
-    def nrows(self,bintable):
-        '''The number of rows of the input bintable
+    def nrows(self, bintable):
+        """The number of rows of the input bintable
 
         Parameters
         ----------
@@ -429,11 +466,11 @@ def nrows(self,bintable):
         -------
             nrows : int
                 Number of rows, i.e., the length of the input bintable
-        '''
+        """
         return self._nrows[bintable]
 
-    def nchan(self,bintable):
-        '''The number of channels per row of the input bintable. Assumes all rows have same length.
+    def nchan(self, bintable):
+        """The number of channels per row of the input bintable. Assumes all rows have same length.
 
         Parameters
         ----------
@@ -444,11 +481,11 @@ def nchan(self,bintable):
         -------
             nchan : int
                 Number channels in the first spectrum of the input bintbale
-        '''
-        return np.shape(self.rawspectrum(bintable,1))[0]
-    
-    def npol(self,bintable):
-        '''The number of polarizations present in the input bintable. 
+        """
+        return np.shape(self.rawspectrum(bintable, 1))[0]
+
+    def npol(self, bintable):
+        """The number of polarizations present in the input bintable.
 
         Parameters
         ----------
@@ -459,11 +496,11 @@ def npol(self,bintable):
         -------
             npol: int
                 Number of polarizations as given by `CRVAL4` FITS header keyword.
-        '''
-        return len(self.udata(bintable,'CRVAL4'))
-    
-    def sources(self,bintable):
-        '''The number of sources present in the input bintable. 
+        """
+        return len(self.udata(bintable, "CRVAL4"))
+
+    def sources(self, bintable):
+        """The number of sources present in the input bintable.
 
         Parameters
         ----------
@@ -474,12 +511,12 @@ def sources(self,bintable):
         -------
             sources: int
                 Number of sources as given by `OBJECT` FITS header keyword.
-        '''
-        return self.udata(bintable,'OBJECT')
-    
-    def scans(self,bintable):
-        #@TODO move this to GBTFISLoad?
-        '''The number of scans resent in the input bintable. 
+        """
+        return self.udata(bintable, "OBJECT")
+
+    def scans(self, bintable):
+        # @TODO move this to GBTFISLoad?
+        """The number of scans resent in the input bintable.
 
         Parameters
         ----------
@@ -490,46 +527,46 @@ def scans(self,bintable):
         -------
             scans: int
                 Number of scans as given by `SCAN` FITS header keyword.
-        '''
-        return self.udata(bintable,'SCAN') #self.ushow(bintable,'SCAN')
-    
-    def _summary(self,bintable):
-        j=bintable
-        nrows = self.naxis(j,2)
-        nflds = self._binheader[j]['TFIELDS']
-        restfreq = np.unique(self._ptable[j]['RESTFREQ'])/1.0E9
-    #
-        print("HDU       %d" %  (j+1))
-        print("BINTABLE: %d rows x %d cols with %d chans" % (self._nrows[j],nflds,self.nchan(j)))
-        print("Selected  %d/%d rows" % (self._nrows[j],nrows))
-        print("Sources: ",self.sources(j))
-        print("RESTFREQ:",restfreq,'GHz')
-        print("Scans:   ",self.scans(j))
-        print("Npol:    ",self.npol(j))   
-        print("Nint:    ",self.nintegrations(j))
-        
+        """
+        return self.udata(bintable, "SCAN")  # self.ushow(bintable,'SCAN')
+
+    def _summary(self, bintable):
+        j = bintable
+        nrows = self.naxis(j, 2)
+        nflds = self._binheader[j]["TFIELDS"]
+        restfreq = np.unique(self._ptable[j]["RESTFREQ"]) / 1.0e9
+        #
+        print("HDU       %d" % (j + 1))
+        print("BINTABLE: %d rows x %d cols with %d chans" % (self._nrows[j], nflds, self.nchan(j)))
+        print("Selected  %d/%d rows" % (self._nrows[j], nrows))
+        print("Sources: ", self.sources(j))
+        print("RESTFREQ:", restfreq, "GHz")
+        print("Scans:   ", self.scans(j))
+        print("Npol:    ", self.npol(j))
+        print("Nint:    ", self.nintegrations(j))
+
     def summary(self):
         """Print a summary of each record of the data"""
-        print("File:     %s"%self._filename)
+        print("File:     %s" % self._filename)
         for i in range(len(self._bintable)):
-            print("i=",i)
+            print("i=", i)
             self._summary(i)
-    
+
     def __len__(self):
         return self.nrows
-    
+
     def __repr__(self):
-        return self._filename    
+        return self._filename
 
-    def _bintable_from_rows(self,rows=None,bintable=None):
-        """extract a bintable from an existing 
+    def _bintable_from_rows(self, rows=None, bintable=None):
+        """extract a bintable from an existing
            bintable in this SDFITSLoad object
-            
+
         Parameters
         ----------
 
             rows: int or list-like
-                Range of rows in the bintable(s) to write out. e.g. 0, [14,25,32]. 
+                Range of rows in the bintable(s) to write out. e.g. 0, [14,25,32].
             bintable :  int
                 The index of the `bintable` attribute
 
@@ -539,17 +576,17 @@ def _bintable_from_rows(self,rows=None,bintable=None):
                 The binary table HDU created containing the selected rows
 
         """
-        # ensure it is a list if int was given 
+        # ensure it is a list if int was given
         if type(rows) == int:
             rows = [rows]
         outbintable = self._bintable[bintable].copy()
-        #print(f"bintable copy data length {len(outbintable.data)}")
+        # print(f"bintable copy data length {len(outbintable.data)}")
         outbintable.data = outbintable.data[rows]
-        #print(f"bintable rows data length {len(outbintable.data)}")
+        # print(f"bintable rows data length {len(outbintable.data)}")
         outbintable.update()
         return outbintable
 
-    def write(self,fileobj,rows=None,bintable=None,output_verify="exception",overwrite=False,checksum=False):
+    def write(self, fileobj, rows=None, bintable=None, output_verify="exception", overwrite=False, checksum=False):
         """
         Write the `SDFITSLoad` to a new file, potentially sub-selecting rows or bintables.
 
@@ -584,25 +621,21 @@ def write(self,fileobj,rows=None,bintable=None,output_verify="exception",overwri
         """
         if bintable is None:
             if rows is None:
-                # write out everything 
-                self._hdu.writeto(fileobj,
-                    output_verify=output_verify,
-                    overwrite=overwrite,checksum=checksum)
+                # write out everything
+                self._hdu.writeto(fileobj, output_verify=output_verify, overwrite=overwrite, checksum=checksum)
             else:
                 raise ValueError("You must specify bintable if you specify rows")
         else:
             if rows is None:
                 # bin table index counts from 0 and starts at the 2nd HDU (hdu index 1), so add 2
-                self._hdu[0:bintable+2]._hdu.writeto(fileobj,
-                    output_verify=output_verify, 
-                    overwrite=overwrite, checksum=checksum)
+                self._hdu[0 : bintable + 2]._hdu.writeto(
+                    fileobj, output_verify=output_verify, overwrite=overwrite, checksum=checksum
+                )
             else:
                 hdu0 = self._hdu[0].copy()
                 # need to get imports correct first
-                #hdu0.header["DYSHVER"] = ('dysh '+version(), "This file was created by dysh")
+                # hdu0.header["DYSHVER"] = ('dysh '+version(), "This file was created by dysh")
                 outhdu = fits.HDUList(hdu0)
-                outbintable = self._bintable_from_rows(rows,bintable)
+                outbintable = self._bintable_from_rows(rows, bintable)
                 outhdu.append(outbintable)
-                outhdu.writeto(fileobj,
-                    output_verify=output_verify,
-                    overwrite=overwrite, checksum=checksum)
+                outhdu.writeto(fileobj, output_verify=output_verify, overwrite=overwrite, checksum=checksum)
diff --git a/src/dysh/fits/tests/test_gbtfitsload.py b/src/dysh/fits/tests/test_gbtfitsload.py
index 51c3e604..0e704a3f 100644
--- a/src/dysh/fits/tests/test_gbtfitsload.py
+++ b/src/dysh/fits/tests/test_gbtfitsload.py
@@ -1,40 +1,35 @@
-
 import os
-import pytest
 import pathlib
-import numpy as np
 
+import dysh
+import numpy as np
 from astropy.io import fits
 from astropy.utils.data import (
-                    get_pkg_data_filename,
-                    get_pkg_data_filenames,
-                    )
-
-import dysh
+    get_pkg_data_filename,
+    get_pkg_data_filenames,
+)
 from dysh.fits import gbtfitsload
 
-
 dysh_root = pathlib.Path(dysh.__file__).parent.resolve()
 
 
-class TestGBTFITSLoad():
-    """
-    """
+class TestGBTFITSLoad:
+    """ """
 
     def setup_method(self):
         self._file_list = list(get_pkg_data_filenames("data/", pattern="*.fits"))
 
     def test_load(self):
-
-        expected = {"TGBT21A_501_11.raw.vegas.fits": 4,
-                    "TGBT21A_501_11_getps_scan_152_intnum_0_ifnum_0_plnum_0.fits": 1,
-                    "TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_0.fits": 1,
-                    "TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_1.fits": 1,
-                    "TGBT21A_501_11_ifnum_0_int_0-2.fits": 24,
-                    "TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits": 1,
-                    "TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_1.fits": 1,
-                    "TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0.fits": 1,
-                    }
+        expected = {
+            "TGBT21A_501_11.raw.vegas.fits": 4,
+            "TGBT21A_501_11_getps_scan_152_intnum_0_ifnum_0_plnum_0.fits": 1,
+            "TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_0.fits": 1,
+            "TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_1.fits": 1,
+            "TGBT21A_501_11_ifnum_0_int_0-2.fits": 24,
+            "TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits": 1,
+            "TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_1.fits": 1,
+            "TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0.fits": 1,
+        }
 
         for fnm in self._file_list:
             print(fnm)
@@ -43,10 +38,8 @@ def test_load(self):
             sdf = gbtfitsload.GBTFITSLoad(fnm)
             assert len(sdf._ptable[0]) == expected[filename]
 
-
     def test_getps_single_int(self):
-        """
-        """
+        """ """
 
         gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_getps_scan_152_intnum_0_ifnum_0_plnum_0.fits")
         # We should probably use dysh to open the file...
@@ -64,13 +57,13 @@ def test_getps_single_int(self):
         assert np.all(abs(diff[~np.isnan(diff)]) < 5e-7)
         assert np.isnan(diff[3072])
 
-
     def test_gettp_single_int(self):
-        """
-        """
+        """ """
 
         # Get the answer from GBTIDL.
-        gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_1.fits")
+        gbtidl_file = get_pkg_data_filename(
+            "data/TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_1.fits"
+        )
         hdu = fits.open(gbtidl_file)
         gbtidl_gettp = hdu[1].data["DATA"][0]
 
@@ -85,7 +78,9 @@ def test_gettp_single_int(self):
 
         # Now with the noise diode Off.
         tps_off = sdf.gettp(152, sig=True, cal=False, calibrate=False)
-        gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_0.fits")
+        gbtidl_file = get_pkg_data_filename(
+            "data/TGBT21A_501_11_gettp_scan_152_intnum_0_ifnum_0_plnum_0_cal_state_0.fits"
+        )
         hdu = fits.open(gbtidl_file)
         gbtidl_gettp = hdu[1].data["DATA"][0]
         diff = tps_off.total_power(0).flux.value - gbtidl_gettp
@@ -93,8 +88,8 @@ def test_gettp_single_int(self):
 
         # Now, both on and off.
         tps = sdf.gettp(152, sig=True, cal=True)
-        tps_tavg = tps.timeaverage()
-        #gbtidl_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0.fits"
+        tps.timeaverage()
+        # gbtidl_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0.fits"
         gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0.fits")
         hdu = fits.open(gbtidl_file)
         table = hdu[1].data
diff --git a/src/dysh/plot/__init__.py b/src/dysh/plot/__init__.py
index d9405f52..f0ff421e 100644
--- a/src/dysh/plot/__init__.py
+++ b/src/dysh/plot/__init__.py
@@ -1,2 +1,2 @@
 """Classes and functions for plotting spectra and SDFITS data"""
-__all__ = [  "specplot "]
+__all__ = ["specplot "]
diff --git a/src/dysh/plot/specplot.py b/src/dysh/plot/specplot.py
index 63d75558..77216e2f 100644
--- a/src/dysh/plot/specplot.py
+++ b/src/dysh/plot/specplot.py
@@ -1,17 +1,19 @@
+import astropy.units as u
 import matplotlib.pyplot as plt
 import numpy as np
-import astropy.units as u
-import copy
+
 """Plot a spectrum using matplotlib"""
-class SpectrumPlot():
-    '''
+
+
+class SpectrumPlot:
+    """
     The SpectrumPlot class is for simple plotting of a ~spectrum.Spectrum
     using matplotlib functions.   Plots attributes are modified using keywords
     (\*\*kwargs) described below SpectrumPlot will attempt to make smart default
     choices for the plot if no additional keywords are given.
     The attributes are "sticky" meaning that an attribute set via
     instantiation or by the `plot()` method will stay set until changed
-    or reset using the `reset()` method.  
+    or reset using the `reset()` method.
 
     Parameters
     ----------
@@ -23,7 +25,7 @@ class SpectrumPlot():
     Keyword Arguments
     -----------------
         xaxis_unit : str or ~astrpy.unit.Unit
-            The units to use on the x-axis, e.g. "km/s" to plot velocity 
+            The units to use on the x-axis, e.g. "km/s" to plot velocity
         yaxis_unit : str or ~astrpy.unit.Unit
             The units to use on the y-axis
         xmin : float
@@ -54,34 +56,37 @@ class SpectrumPlot():
             plot aspect ratio, default: 'auto'
         show_baseline : bool
             show the baseline - not yet implemented
-    '''
+    """
+
     # loc, legend, bbox_to_anchor
 
-    def __init__(self,spectrum,**kwargs):
+    def __init__(self, spectrum, **kwargs):
         self.reset()
         self._plot_kwargs.update(kwargs)
         self._plt = plt
         self._figure = None
         self._axis = None
         self._spectrum = spectrum
-        self._title = self._plot_kwargs['title']
+        self._title = self._plot_kwargs["title"]
 
-# def __call__ (see pyspeckit)
+    # def __call__ (see pyspeckit)
 
     @property
     def axis(self):
         """The underlying :class:`~matplotlib.Axes` object"""
         return self._axis
+
     @property
     def figure(self):
         """The underlying :class:`~matplotlib.Figure` object"""
         return self._figure
+
     @property
     def spectrum(self):
         """The underlying `~spectra.spectrum.Spectrum`"""
         return self._spectrum
 
-    def plot(self,**kwargs):
+    def plot(self, **kwargs):
         """
         Plot the spectrum.
 
@@ -92,120 +97,118 @@ def plot(self,**kwargs):
         """
         # xtype = 'velocity, 'frequency', 'wavelength'
         self._plot_kwargs.update(kwargs)
-        #if self._figure is None:
+        # if self._figure is None:
         if True:
-            self._figure,self._axis = self._plt.subplots(figsize=self._plot_kwargs['figsize'])
-        #else:
+            self._figure, self._axis = self._plt.subplots(figsize=self._plot_kwargs["figsize"])
+        # else:
         #    self._axis.cla()
 
         s = self._spectrum
         sa = s.spectral_axis
-        lw =  self._plot_kwargs['linewidth']
+        lw = self._plot_kwargs["linewidth"]
         xunit = self._plot_kwargs["xaxis_unit"]
         yunit = self._plot_kwargs["yaxis_unit"]
         if xunit is not None:
             if "chan" in xunit:
                 sa = np.arange(len(sa))
-                self._plot_kwargs['xlabel'] = "Channel"
+                self._plot_kwargs["xlabel"] = "Channel"
             else:
-                # convert the x axis to the requested 
-                #print(f"EQUIV {equiv} doppler_rest {sa.doppler_rest} [{rfq}] convention {convention}")
-                #sa = s.spectral_axis.to( self._plot_kwargs["xaxis_unit"], equivalencies=equiv,doppler_rest=rfq, doppler_convention=convention)
-                sa = s.velocity.to( self._plot_kwargs["xaxis_unit"], equivalencies=s.equivalencies)
-                self._plot_kwargs['xlabel'] = f'Velocity ({xunit})'
+                # convert the x axis to the requested
+                # print(f"EQUIV {equiv} doppler_rest {sa.doppler_rest} [{rfq}] convention {convention}")
+                # sa = s.spectral_axis.to( self._plot_kwargs["xaxis_unit"], equivalencies=equiv,doppler_rest=rfq, doppler_convention=convention)
+                sa = s.velocity.to(self._plot_kwargs["xaxis_unit"], equivalencies=s.equivalencies)
+                self._plot_kwargs["xlabel"] = f"Velocity ({xunit})"
         sf = s.flux
         if yunit is not None:
             sf = s.flux.to(yunit)
-        self._axis.plot(sa,sf,color=self._plot_kwargs['color'], lw = lw)
-        self._axis.set_xlim(self._plot_kwargs['xmin'],self._plot_kwargs['xmax'])
-        self._axis.set_ylim(self._plot_kwargs['ymin'],self._plot_kwargs['ymax'])
-        self._axis.tick_params(axis='both',which='both',bottom=True,top=True,left=True,right=True,direction='in')
-        if self._plot_kwargs['grid']:
-            self._axis.grid(visible=True,which='major',axis='both',lw=lw/2,
-                                color='k',alpha=0.33)
-            self._axis.grid(visible=True,which='minor',axis='both',lw=lw/2,
-                                color='k',alpha=0.22,linestyle='--')
+        self._axis.plot(sa, sf, color=self._plot_kwargs["color"], lw=lw)
+        self._axis.set_xlim(self._plot_kwargs["xmin"], self._plot_kwargs["xmax"])
+        self._axis.set_ylim(self._plot_kwargs["ymin"], self._plot_kwargs["ymax"])
+        self._axis.tick_params(axis="both", which="both", bottom=True, top=True, left=True, right=True, direction="in")
+        if self._plot_kwargs["grid"]:
+            self._axis.grid(visible=True, which="major", axis="both", lw=lw / 2, color="k", alpha=0.33)
+            self._axis.grid(visible=True, which="minor", axis="both", lw=lw / 2, color="k", alpha=0.22, linestyle="--")
 
         self._set_labels(**self._plot_kwargs)
-        #self._axis.axhline(y=0,color='red',lw=2)
+        # self._axis.axhline(y=0,color='red',lw=2)
         self.refresh()
 
     def reset(self):
         """Reset the plot keyword arguments to their defaults."""
         self._plot_kwargs = {
-            'xmin': None,
-            'xmax': None,
-            'ymin': None,
-            'ymax': None,
-            'xlabel':None,
-            'ylabel':None,
-            'xaxis_unit': None,
-            'yaxis_unit': None,
-            'grid' :False,
-            'figsize':None,
+            "xmin": None,
+            "xmax": None,
+            "ymin": None,
+            "ymax": None,
+            "xlabel": None,
+            "ylabel": None,
+            "xaxis_unit": None,
+            "yaxis_unit": None,
+            "grid": False,
+            "figsize": None,
             #'capsize':3,
-            'linewidth': 2.0,
-            'linestyle': 'steps-mid',
-            'markersize': 8,
-            'color':None,
-            'title':None,
+            "linewidth": 2.0,
+            "linestyle": "steps-mid",
+            "markersize": 8,
+            "color": None,
+            "title": None,
             #'axis':None,
             #'label':None,
-            'aspect': 'auto',
-            'bbox_to_anchor':None,
-            'loc':"best",
-            'legend':None,
-            'show_baseline':True,
-            'test': False
+            "aspect": "auto",
+            "bbox_to_anchor": None,
+            "loc": "best",
+            "legend": None,
+            "show_baseline": True,
+            "test": False,
         }
 
-    def _set_labels(self,title=None,xlabel=None,ylabel=None,**kwargs):
+    def _set_labels(self, title=None, xlabel=None, ylabel=None, **kwargs):
         """Set x and y labels according to spectral units
 
-           Parameters
-           ----------
-           title : str
-               plot title
-           xlabel : str
-               x-axis label
-           ylabel : str
-               x-axis label
-           \*\*kwargs : various
-               other keyword=value arguments
+        Parameters
+        ----------
+        title : str
+            plot title
+        xlabel : str
+            x-axis label
+        ylabel : str
+            x-axis label
+        \*\*kwargs : various
+            other keyword=value arguments
         """
         if title is not None:
             self._title = title
-        if hasattr(self.spectrum.wcs,'wcs'):
-           ctype = self.spectrum.wcs.wcs.ctype
+        if hasattr(self.spectrum.wcs, "wcs"):
+            ctype = self.spectrum.wcs.wcs.ctype
         elif self.spectrum.meta is not None:
-           ctype = []
-           ctype.append(self.spectrum.meta.get('CTYPE1',None))
-           ctype.append(self.spectrum.meta.get('CTYPE2',None))
-           ctype.append(self.spectrum.meta.get('CTYPE3',None))
-        #print('ctype is ',ctype)
-        if kwargs.get("xaxis_unit",None) is not None:
+            ctype = []
+            ctype.append(self.spectrum.meta.get("CTYPE1", None))
+            ctype.append(self.spectrum.meta.get("CTYPE2", None))
+            ctype.append(self.spectrum.meta.get("CTYPE3", None))
+        # print('ctype is ',ctype)
+        if kwargs.get("xaxis_unit", None) is not None:
             xunit = kwargs["xaxis_unit"]
         else:
             xunit = self.spectrum.spectral_axis.unit
-        if kwargs.get("yaxis_unit",None) is not None:
+        if kwargs.get("yaxis_unit", None) is not None:
             yunit = u.Unit(kwargs["yaxis_unit"])
         else:
             yunit = self.spectrum.unit
         if xlabel is not None:
             self.axis.set_xlabel(xlabel)
-        elif ctype[0] in ['FREQ']:
-            xlabel = f'Frequency ({xunit})'
+        elif ctype[0] in ["FREQ"]:
+            xlabel = f"Frequency ({xunit})"
             self.axis.set_xlabel(xlabel)
-        elif ctype[0] in ['VELO', 'VRAD', 'VOPT']:
-            xlabel = f'Velocity ({xunit})'
+        elif ctype[0] in ["VELO", "VRAD", "VOPT"]:
+            xlabel = f"Velocity ({xunit})"
             self.axis.set_xlabel(xlabel)
-        elif ctype[0] in ['WAVE', 'AWAV']:
-            xlabel = f'Wavelength({xunit})'
+        elif ctype[0] in ["WAVE", "AWAV"]:
+            xlabel = f"Wavelength({xunit})"
             self.axis.set_xlabel(xlabel)
         elif xunit is not None:
             xlabel = xunit
             self.axis.set_xlabel(xlabel)
-        #print(f"ylabel {ylabel} yunit {yunit} sunit {self.spectrum.unit}")
+        # print(f"ylabel {ylabel} yunit {yunit} sunit {self.spectrum.unit}")
         if ylabel is not None:
             self.axis.set_ylabel(ylabel)
         elif yunit.is_equivalent(u.K):
@@ -214,27 +217,24 @@ def _set_labels(self,title=None,xlabel=None,ylabel=None,**kwargs):
             snu = r"$S_{\nu}$"
             self.axis.set_ylabel(f"{snu} ({yunit})")
 
-    def _show_exclude(self,**kwargs):
-        '''TODO: Method to show the exclude array on the plot'''
+    def _show_exclude(self, **kwargs):
+        """TODO: Method to show the exclude array on the plot"""
         kwargs_opts = {
-            'loc': "bottom", #top,bottom ?
-            'color' : 'silver',
+            "loc": "bottom",  # top,bottom ?
+            "color": "silver",
         }
         kwargs_opts.update(kwargs)
-        #if kwargs_opts['loc'] == 'bottom':
+        # if kwargs_opts['loc'] == 'bottom':
         #    self._ax.axhline
-        
-
 
     def refresh(self):
         """Refresh the plot"""
         if self.axis is not None:
             self.axis.figure.canvas.draw()
-            #print('redrawing')
-            #self.axis.figure.canvas.draw_idle()
+            # print('redrawing')
+            # self.axis.figure.canvas.draw_idle()
             self._plt.show()
 
-    def savefig(self,file,**kwargs):
+    def savefig(self, file, **kwargs):
         """Save the plot"""
-        self.figure.savefig(file,*kwargs)
-
+        self.figure.savefig(file, *kwargs)
diff --git a/src/dysh/spectra/__init__.py b/src/dysh/spectra/__init__.py
index e56cc16c..e69d1ade 100644
--- a/src/dysh/spectra/__init__.py
+++ b/src/dysh/spectra/__init__.py
@@ -1,3 +1,3 @@
 """Classes and functions for managing and processing spectra"""
-__all__ = [ "obsblock", "spectrum" , "core"]
+__all__ = ["obsblock", "spectrum", "core"]
 from .core import *
diff --git a/src/dysh/spectra/core.py b/src/dysh/spectra/core.py
index d8178d99..85af1794 100644
--- a/src/dysh/spectra/core.py
+++ b/src/dysh/spectra/core.py
@@ -1,19 +1,17 @@
-#import sys
-#import copy
-import numpy as np
-from astropy.wcs import WCS
-from astropy.io import fits
+# import sys
+# import copy
+import warnings
+
 import astropy.units as u
-#from astropy.table import Table
-from astropy.modeling.polynomial import Polynomial1D,Chebyshev1D
-from astropy.modeling.fitting import LevMarLSQFitter,LinearLSQFitter
-from specutils import Spectrum1D, SpectrumList,SpectralRegion
+import numpy as np
+from astropy.modeling.fitting import LinearLSQFitter
+
+# from astropy.table import Table
+from astropy.modeling.polynomial import Chebyshev1D, Polynomial1D
+from specutils import SpectralRegion
 from specutils.fitting import fit_continuum
-import matplotlib.pyplot as plt
-from ..util import uniq
-import warnings
 
-#def baseline_all(speclist,order,exclude=None,**kwargs):
+# def baseline_all(speclist,order,exclude=None,**kwargs):
 #    kwargs_opts = {
 #        'remove': False,
 #        'show': False,
@@ -24,75 +22,77 @@
 #    for p in speclist:
 #        p.baseline(order,exclude,**kwargs)
 
-def average(data,axis=0,weights=None):
+
+def average(data, axis=0, weights=None):
     """Average a group of spectra or scans.
-        TODO: allow data to be SpectrumList or array of Spectrum
-       
-       Parameters
-       ----------
-       data : `~numpy.ndarray`
-           The spectral data, typically with shape (nspect,nchan). 
-       axis : int
-           The axis over which to average the data.  Default axis=0 will return the average spectrum
-           if shape is (nspect,nchan)
-       weights : `~numpy.ndarray`
-           The weights to use in averaging.  These might typically be system temperature based. 
-           The weights array must be the length of the axis over which the average is taken.
-           Default: None will use equal weights
-
-       Returns
-       -------
-       average : `~numpy.ndarray`
-           The average along the input axis
+     TODO: allow data to be SpectrumList or array of Spectrum
+
+    Parameters
+    ----------
+    data : `~numpy.ndarray`
+        The spectral data, typically with shape (nspect,nchan).
+    axis : int
+        The axis over which to average the data.  Default axis=0 will return the average spectrum
+        if shape is (nspect,nchan)
+    weights : `~numpy.ndarray`
+        The weights to use in averaging.  These might typically be system temperature based.
+        The weights array must be the length of the axis over which the average is taken.
+        Default: None will use equal weights
+
+    Returns
+    -------
+    average : `~numpy.ndarray`
+        The average along the input axis
     """
-    return np.average(data,axis,weights)
+    return np.average(data, axis, weights)
+
 
-def exclude_to_region(exclude,refspec,fix_exclude=False):
+def exclude_to_region(exclude, refspec, fix_exclude=False):
     """Convert an exclude list to a list of ~specutuls.SpectralRegion.
 
-       Parameters
-       ----------        
+     Parameters
+     ----------
+
+          exclude : list of 2-tuples of int or `~astropy.units.Quantity`, or `~specutils.SpectralRegion`
+              List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  Examples:
 
-            exclude : list of 2-tuples of int or `~astropy.units.Quantity`, or `~specutils.SpectralRegion`
-                List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  Examples:
+              One channel-based region:
 
-                One channel-based region: 
+              >>> [11,51]
 
-                >>> [11,51] 
+              Two channel-based regions:
 
-                Two channel-based regions: 
+              >>> [(11,51),(99,123)]
 
-                >>> [(11,51),(99,123)] 
+              One `~astropy.units.Quantity` region:
 
-                One `~astropy.units.Quantity` region: 
+              >>> [110.198*u.GHz,110.204*u.GHz].
 
-                >>> [110.198*u.GHz,110.204*u.GHz]. 
+              One compound `~specutils.SpectralRegion`:
 
-                One compound `~specutils.SpectralRegion`: 
+              >>> SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
 
-                >>> SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
-                
-            refspec: `~spectra.spectrum.Spectrum`
-                The reference spectrum whose spectral axis will be used 
-                when converting between exclude and axis units (e.g. channels to GHz).
-            fix_exclude: bool
-                If True, fix exclude regions that are out of bounds of the specctral axis to be within the spectral axis. Default:False
- 
-      Returns
-      ----------        
-            regionlist : list of `~specutil.SpectralRegion`
-                A list of `~specutil.SpectralRegion` corresponding to `exclude` with units of the `refspec.spectral_axis`.
+          refspec: `~spectra.spectrum.Spectrum`
+              The reference spectrum whose spectral axis will be used
+              when converting between exclude and axis units (e.g. channels to GHz).
+          fix_exclude: bool
+              If True, fix exclude regions that are out of bounds of the specctral axis to be within the spectral axis. Default:False
+
+    Returns
+    ----------
+          regionlist : list of `~specutil.SpectralRegion`
+              A list of `~specutil.SpectralRegion` corresponding to `exclude` with units of the `refspec.spectral_axis`.
 
     """
-    regionlist = [] 
+    regionlist = []
     p = refspec
     sa = refspec.spectral_axis
     if exclude is not None:
-        regionlist = [] 
+        regionlist = []
         # a single SpectralRegion was given
-        if isinstance(exclude,SpectralRegion):
+        if isinstance(exclude, SpectralRegion):
             b = exclude.bounds
-            if b[0]<sa[0] or b[1]>sa[1]:
+            if b[0] < sa[0] or b[1] > sa[1]:
                 msg = f"Exclude limits {pair} are not fully within the spectral axis {sa}"
                 raise Exception(msg)
             regionlist.append(exclude)
@@ -104,158 +104,165 @@ def exclude_to_region(exclude,refspec,fix_exclude=False):
             # have to do this.
             if len(np.shape(exclude[0])) == 0:
                 exclude = [exclude]
-            #NB: we are assuming that a SpectralAxis is always [lower...upper].  Is this true???
+            # NB: we are assuming that a SpectralAxis is always [lower...upper].  Is this true???
             for pair in exclude:
                 if type(pair[0]) == int:
-                # convert channel to spectral axis units
-                    lastchan = len(sa)-1
-                    msg = f"Exclude limits {pair} are not fully within the spectral axis [0,{lastchan}]." 
+                    # convert channel to spectral axis units
+                    lastchan = len(sa) - 1
+                    msg = f"Exclude limits {pair} are not fully within the spectral axis [0,{lastchan}]."
                     if pair[0] < 0 or pair[1] > lastchan:
                         if fix_exclude:
                             msg += f" Setting upper limit to {lastchan}."
                             pair[1] = lastchan
-                            warnings.warn(msg) 
+                            warnings.warn(msg)
                         else:
                             raise Exception(msg)
-                    pair = [sa[pair[0]],sa[pair[1]]]
+                    pair = [sa[pair[0]], sa[pair[1]]]
                 # if it is already a spectral region no additional
                 # work is needed
-                #@TODO we should test that the SpectralRegion is not out of bounds
-                if isinstance(pair[0],SpectralRegion):
+                # @TODO we should test that the SpectralRegion is not out of bounds
+                if isinstance(pair[0], SpectralRegion):
                     b = pair[0].bounds
-                    if b[0]<sa[0] or b[1]>sa[1]:
+                    if b[0] < sa[0] or b[1] > sa[1]:
                         msg = f"Exclude limits {pair} are not fully within the spectral axis {p.spectral_axis}"
                         raise Exception(msg)
                     regionlist.append(pair)
-                else: # it is a Quantity that may need conversion to spectral_axis units
+                else:  # it is a Quantity that may need conversion to spectral_axis units
                     if pair[0].unit.is_equivalent("km/s"):
-                        offset = p.rest_value - p.radial_velocity.to(sa.unit,equivalencies = p.equivalencies)
+                        offset = p.rest_value - p.radial_velocity.to(sa.unit, equivalencies=p.equivalencies)
                     else:
                         offset = 0
-                    pair[0] = offset + pair[0].to(sa.unit,equivalencies = p.equivalencies)
-                    pair[1] = offset + pair[1].to(sa.unit,equivalencies = p.equivalencies)
+                    pair[0] = offset + pair[0].to(sa.unit, equivalencies=p.equivalencies)
+                    pair[1] = offset + pair[1].to(sa.unit, equivalencies=p.equivalencies)
                     # Ensure test is with sorted [lower,upper]
-                    pair = sorted(pair) 
-                    salimits = sorted([sa[0],sa[-1]])
+                    pair = sorted(pair)
+                    salimits = sorted([sa[0], sa[-1]])
                     if pair[0] < salimits[0] or pair[1] > salimits[-1]:
-                        msg = f"Exclude limits {pair} are not fully within the spectral axis {[salimits[0],salimits[-1]]}."
+                        msg = (
+                            f"Exclude limits {pair} are not fully within the spectral axis"
+                            f" {[salimits[0],salimits[-1]]}."
+                        )
                         if fix_exclude:
                             msg += f" Setting upper limit to {p.spectral_axis[-1]}."
                             pair[1] = sa[-1]
-                            warnings.warn(msg) 
+                            warnings.warn(msg)
                         else:
                             raise Exception(msg)
-                    sr = SpectralRegion(pair[0],pair[1])
+                    sr = SpectralRegion(pair[0], pair[1])
                     regionlist.append(sr)
 
             return regionlist
 
-def region_to_axis_indices(region,refspec):
+
+def region_to_axis_indices(region, refspec):
     """
-        Parameters
-        ----------
-            region : `~specutils.SpectralRegion`
-            refspec: `~spectra.spectrum.Spectrum`
-                The reference spectrum whose spectral axis will be used 
-                when converting between exclude and axis units (e.g., channels to GHz).
-
-        Returns
-        -------
-            indices : 2-tuple of int
-                The array indices in `refspec` corresponding to `region.bounds`
+    Parameters
+    ----------
+        region : `~specutils.SpectralRegion`
+        refspec: `~spectra.spectrum.Spectrum`
+            The reference spectrum whose spectral axis will be used
+            when converting between exclude and axis units (e.g., channels to GHz).
+
+    Returns
+    -------
+        indices : 2-tuple of int
+            The array indices in `refspec` corresponding to `region.bounds`
     """
     # Spectral region to indices in an input spectral axis.
-    #@TODO needs to work for multiple spectral regions? or just loop outside this call
-    p = refspec
+    # @TODO needs to work for multiple spectral regions? or just loop outside this call
     sa = refspec.spectral_axis
     if region.lower.unit != sa.unit:
-        #@todo if they are conformable, then allow it and convert
+        # @todo if they are conformable, then allow it and convert
         raise Exception(f"Axis units of region [{region.lower.unit}] and refspec [{sa.unit}] not identical")
     b = [x.value for x in region.bounds]
     indices = np.abs(np.subtract.outer(sa.value, b)).argmin(0)
     return indices
 
-def exclude_to_mask(exclude,refspec):
+
+def exclude_to_mask(exclude, refspec):
     # set a mask based on an exclude region
     # mask ~ exclude_to_indices(exclude_to_region())
     pass
 
-def baseline(spectrum,order,exclude=None,**kwargs):
+
+def baseline(spectrum, order, exclude=None, **kwargs):
     """Fit a baseline for a spectrum
 
-       Parameters
-       ----------        
-       spectrum : `~spectra.spectrum.Spectrum`
-           The input spectrum
-       order : int
-           The order of the polynomial series, a.k.a. baseline order
-       exclude : list of 2-tuples of int or `~astropy.units.Quantity`, or `~specutils.SpectralRegion`
-           List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  Examples:
+    Parameters
+    ----------
+    spectrum : `~spectra.spectrum.Spectrum`
+        The input spectrum
+    order : int
+        The order of the polynomial series, a.k.a. baseline order
+    exclude : list of 2-tuples of int or `~astropy.units.Quantity`, or `~specutils.SpectralRegion`
+        List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  Examples:
+
+        One channel-based region:
 
-           One channel-based region: 
+        >>> [11,51]
 
-           >>> [11,51] 
+        Two channel-based regions:
 
-           Two channel-based regions: 
+        >>> [(11,51),(99,123)]
 
-           >>> [(11,51),(99,123)] 
+        One `~astropy.units.Quantity` region:
 
-           One `~astropy.units.Quantity` region: 
+        >>> [110.198*u.GHz,110.204*u.GHz].
 
-           >>> [110.198*u.GHz,110.204*u.GHz]. 
+        One compound `~specutils.SpectralRegion`:
 
-           One compound `~specutils.SpectralRegion`: 
+        >>> SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
+        Default: no exclude region
 
-           >>> SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
-           Default: no exclude region
+    model : str
+        One of 'polynomial' or 'chebyshev', Default: 'polynomial'
+    fitter : `~astropy.fitting._FitterMeta`
+        The fitter to use. Default: `~astropy.fitter.LinearLSQFitter` (with `calc_uncertaintes=True).  Be care when choosing a different fitter to be sure it is optimized for this problem.
 
-       model : str
-           One of 'polynomial' or 'chebyshev', Default: 'polynomial'
-       fitter : `~astropy.fitting._FitterMeta`
-           The fitter to use. Default: `~astropy.fitter.LinearLSQFitter` (with `calc_uncertaintes=True).  Be care when choosing a different fitter to be sure it is optimized for this problem.
+    Returns
+    -------
+    models : list of `~astropy.modeling.Model`
+        The list of models that contain the fitted model parameters.
+        See `~specutuls.fitting.fit_continuum`.
 
-       Returns
-       -------
-       models : list of `~astropy.modeling.Model`
-           The list of models that contain the fitted model parameters.
-           See `~specutuls.fitting.fit_continuum`.
-           
     """
     kwargs_opts = {
         #'show': False,
-        'model':'polynomial',
-        'fitter':  LinearLSQFitter(calc_uncertainties=True),
-        'fix_exclude': False,
-        'exclude_action': 'replace', # {'replace','append',None}
+        "model": "polynomial",
+        "fitter": LinearLSQFitter(calc_uncertainties=True),
+        "fix_exclude": False,
+        "exclude_action": "replace",  # {'replace','append',None}
     }
     kwargs_opts.update(kwargs)
 
     _valid_models = ["polynomial", "chebyshev"]
-    _valid_exclude_actions = ['replace','append',None]
+    _valid_exclude_actions = ["replace", "append", None]
     # @todo replace with minimum_string_match
     if kwargs_opts["model"] not in _valid_models:
         raise ValueError(f'Unrecognized input model {kwargs["model"]}. Must be one of {_valid_models}')
-    if kwargs_opts['model'] == "polynomial":
+    if kwargs_opts["model"] == "polynomial":
         model = Polynomial1D(degree=order)
-    elif kwargs_opts['model'] == "chebyshev":
+    elif kwargs_opts["model"] == "chebyshev":
         model = Chebyshev1D(degree=order)
     else:
         # should never get here, unless we someday allow user to input a astropy.model
         raise ValueError(f'Unrecognized input model {kwargs["model"]}. Must be one of {_valid_models}')
 
-    if kwargs_opts['exclude_action'] not in _valid_exclude_actions:
-        raise ValueError(f'Unrecognized exclude region action {kwargs["exclude_region"]}. Must be one of {_valid_exclude_actions}')
-    fitter = kwargs_opts['fitter']
-    #print(f"MODEL {model} FITTER {fitter}")
+    if kwargs_opts["exclude_action"] not in _valid_exclude_actions:
+        raise ValueError(
+            f'Unrecognized exclude region action {kwargs["exclude_region"]}. Must be one of {_valid_exclude_actions}'
+        )
+    fitter = kwargs_opts["fitter"]
+    # print(f"MODEL {model} FITTER {fitter}")
     p = spectrum
     if np.isnan(p.data).all():
-        #@Todo handle masks
-        return None # or raise exception
+        # @Todo handle masks
+        return None  # or raise exception
     if exclude is not None:
-        regionlist = exclude_to_region(exclude,spectrum,fix_exclude=kwargs_opts['fix_exclude'])
-        if kwargs_opts['exclude_action'] == 'replace':
+        regionlist = exclude_to_region(exclude, spectrum, fix_exclude=kwargs_opts["fix_exclude"])
+        if kwargs_opts["exclude_action"] == "replace":
             p._exclude_regions = regionlist
-        elif kwargs_opts['exclude_action'] == 'append':
+        elif kwargs_opts["exclude_action"] == "append":
             p._exclude_regions.extend(regionlist)
             regionlist = p._exclude_regions
     else:
@@ -263,20 +270,18 @@ def baseline(spectrum,order,exclude=None,**kwargs):
         # exist (they will be a list of SpectralRegions or None)
         regionlist = p._exclude_regions
     print(f"EXCLUDING {regionlist}")
-    return fit_continuum(spectrum=p,
-                model=model,
-                fitter=fitter,
-                exclude_regions=regionlist)
+    return fit_continuum(spectrum=p, model=model, fitter=fitter, exclude_regions=regionlist)
+
 
 def mean_tsys(calon, caloff, tcal, mode=0, fedge=10, nedge=None):
     """
     Get the system temperature from the neighboring calon and caloff, which reflect the state of the noise diode.
-    We define an extra way to set the edge size, nedge, if you prefer to use 
+    We define an extra way to set the edge size, nedge, if you prefer to use
     number of edge channels instead of the inverse fraction.  This implementation recreates GBTIDL's `dcmeantsys`.
-    
+
     Parameters
     ----------
-        calon : `~numpy.ndarray`-like 
+        calon : `~numpy.ndarray`-like
             ON calibration
 
         caloff  :  `~numpy.ndarray`-like
@@ -284,8 +289,8 @@ def mean_tsys(calon, caloff, tcal, mode=0, fedge=10, nedge=None):
 
         tcal  :  `~numpy.ndarray`-like
             calibration temperature
-        
-        mode : int 
+
+        mode : int
             mode=0  Do the mean before the division
             mode=1  Do the mean after the division
             TODO: Ask PJT why the options?
@@ -298,106 +303,106 @@ def mean_tsys(calon, caloff, tcal, mode=0, fedge=10, nedge=None):
 
     Returns
     -------
-        meanTsys : `~numpy.ndarray`-like 
+        meanTsys : `~numpy.ndarray`-like
             The mean system temperature
     """
-    #@todo Pedro thinks about a version that takes a spectrum with multiple SpectralRegions to exclude.
+    # @todo Pedro thinks about a version that takes a spectrum with multiple SpectralRegions to exclude.
     nchan = len(calon)
-    if nedge == None:
-        nedge = nchan // fedge    # 10 %
+    if nedge is None:
+        nedge = nchan // fedge  # 10 %
     # Python uses exclusive array ranges while GBTIDL uses inclusive ones.
     # Therefore we have to add a channel to the upper edge of the range
-    # below in order to reproduce exactly what GBTIDL gets for Tsys.  
+    # below in order to reproduce exactly what GBTIDL gets for Tsys.
     # See github issue #28.
     # Define the channel range once.
-    chrng = slice(nedge,-(nedge-1),1)
+    chrng = slice(nedge, -(nedge - 1), 1)
 
     # Make them doubles. Probably not worth it.
-    caloff = caloff.astype('d')
-    calon = calon.astype('d')
+    caloff = caloff.astype("d")
+    calon = calon.astype("d")
 
-    if mode == 0:  #mode = 0 matches GBTIDL output for Tsys values
+    if mode == 0:  # mode = 0 matches GBTIDL output for Tsys values
         meanoff = np.nanmean(caloff[chrng])
         meandiff = np.nanmean(calon[chrng]) - np.nanmean(caloff[chrng])
         if False:
-            if meandiff < 0  :
+            if meandiff < 0:
                 print(f"moff {meanoff}, mdif {meandiff}, tc {tcal}")
                 print(f"CALON: {calon[nedge:-(nedge-1)]}")
                 print(f"CALOF: {caloff[nedge:-(nedge-1)]}")
                 print(f"DIFF: {calon[nedge:-(nedge-1)]-caloff[nedge:-(nedge-1)]}")
                 print(f"CALOF: {caloff[nedge:-(nedge-1)]}")
-        meanTsys = ( meanoff / meandiff * tcal + tcal/2.0 )
+        meanTsys = meanoff / meandiff * tcal + tcal / 2.0
     else:
-        meanTsys = np.mean( caloff[chrng] / (calon[chrng] - caloff[chrng]) )
-        meanTsys = meanTsys * tcal + tcal/2.0
+        meanTsys = np.mean(caloff[chrng] / (calon[chrng] - caloff[chrng]))
+        meanTsys = meanTsys * tcal + tcal / 2.0
 
     # meandiff can sometimes be negative, which makes Tsys negative!
     # GBTIDL also takes abs(Tsys) because it does sqrt(Tsys^2)
-    return np.abs(meanTsys) 
+    return np.abs(meanTsys)
 
 
 def veldef_to_convention(veldef):
     """given a VELDEF, return the velocity convention expected by Spectrum(1D)
 
-        Parameters
-        ----------
-            veldef : str
-                velocity definition from FITS header, e.g., 'OPTI-HELO', 'VELO-LSR'
-        
-        Returns
-        -------
-            convention : str
-            velocity convention string, one of {'radio', 'optical', 'relativistic'}  or None if `velframe` can't be parsed
+    Parameters
+    ----------
+        veldef : str
+            velocity definition from FITS header, e.g., 'OPTI-HELO', 'VELO-LSR'
+
+    Returns
+    -------
+        convention : str
+        velocity convention string, one of {'radio', 'optical', 'relativistic'}  or None if `velframe` can't be parsed
     """
 
-    #@TODO GBT defines these wrong.  Need to sort out and have special version for GBT
+    # @TODO GBT defines these wrong.  Need to sort out and have special version for GBT
     prefix = veldef[0:4].lower()
     if prefix == "opti":
-        return 'optical'
+        return "optical"
     if prefix == "velo" or prefix == "radi":
-        return 'radio'
+        return "radio"
     if prefix == "rela":
-        return 'relativistic'
+        return "relativistic"
     return None
 
 
-def tsys_weight(exposure,delta_freq,tsys):
+def tsys_weight(exposure, delta_freq, tsys):
     r"""Compute the system temperature based weight(s) using the expression:
-        
-        :math:`w = t_{exp} \times \delta_\nu / T_{sys}^2,`
 
-       where :math:`t_{exp}` is the exposure time, :math:`\delta_\nu` is the frequency resolution, and :math:`T_{sys}` is the system temperature.
+     :math:`w = t_{exp} \times \delta_\nu / T_{sys}^2,`
+
+    where :math:`t_{exp}` is the exposure time, :math:`\delta_\nu` is the frequency resolution, and :math:`T_{sys}` is the system temperature.
 
-       If `exposure`, `delta_freq`, or `tsys` parameters are given as `~astropy.units.Quantity`,
-       they will be converted to seconds, Hz, K, respectively for the calculation.
-       (Not that this really matters since weights are relative to each other)
-    
-       **Note:** The parameters cannot be given as arrays of `~astropy.units.Quantity`, e.g., 
+    If `exposure`, `delta_freq`, or `tsys` parameters are given as `~astropy.units.Quantity`,
+    they will be converted to seconds, Hz, K, respectively for the calculation.
+    (Not that this really matters since weights are relative to each other)
 
-        >>> import astropy.units as u
-        >>> [3*u.s, 4*u.s]   ### WRONG
+    **Note:** The parameters cannot be given as arrays of `~astropy.units.Quantity`, e.g.,
 
-       Rather, if using `~astropy.units.Quantity`, they have to be `~astropy.units.Quantity` objects, e.g., 
+     >>> import astropy.units as u
+     >>> [3*u.s, 4*u.s]   ### WRONG
 
-        >>> [3, 4]*u.s ### RIGHT!
+    Rather, if using `~astropy.units.Quantity`, they have to be `~astropy.units.Quantity` objects, e.g.,
 
-       Parameters
-       ----------
-            exposure : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
-                The exposure time, typically given in seconds
-            delta_freq : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
-                The channel width in frequency units
-            tsys : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
-                The system temperature, typically in K 
+     >>> [3, 4]*u.s ### RIGHT!
 
-       Returns
-       -------
-            weight : `~numpy.ndarray`
-                The weights array
+    Parameters
+    ----------
+         exposure : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
+             The exposure time, typically given in seconds
+         delta_freq : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
+             The channel width in frequency units
+         tsys : `~numpy.ndarray`, float, or `~astropy.units.Quantity`
+             The system temperature, typically in K
+
+    Returns
+    -------
+         weight : `~numpy.ndarray`
+             The weights array
     """
 
     # Quantitys work with abs and power!
-    weight = abs(delta_freq)*exposure*np.power(tsys,-2)
+    weight = abs(delta_freq) * exposure * np.power(tsys, -2)
     if type(weight) == u.Quantity:
         return weight.value.astype(np.longdouble)
     else:
diff --git a/src/dysh/spectra/obsblock.py b/src/dysh/spectra/obsblock.py
index 40b22f65..cedfb40a 100644
--- a/src/dysh/spectra/obsblock.py
+++ b/src/dysh/spectra/obsblock.py
@@ -1,38 +1,19 @@
-import sys
-import copy
-import numpy as np
-from astropy.wcs import WCS
-from astropy.units import cds
-from astropy.modeling.models import Gaussian1D
-from astropy.modeling.polynomial import Polynomial1D
-from astropy.io import fits
-from astropy.modeling import models, fitting
-import astropy.units as u
-from astropy.table import Table
-from astropy.modeling.fitting import LevMarLSQFitter,LinearLSQFitter
-from specutils import Spectrum1D, SpectrumList,SpectralRegion
-from specutils.fitting import fit_continuum
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-from .spectrum import Spectrum
+class Obsblock:
+    """Class that holds a series of spectra on which bulk operations can be performed"""
 
-class Obsblock():
-    '''Class that holds a series of spectra on which bulk operations can be performed'''
-    def __init__(self,speclist,index):
+    def __init__(self, speclist, index):
         self._speclist = speclist
-        self._index = index # pandas dataframe
+        self._index = index  # pandas dataframe
 
-    def __getitem__(self,i):
+    def __getitem__(self, i):
         return self._speclist[i]
 
     def __len__(self):
         return len(self._speclist)
 
-    def __op__(self,opname):
+    def __op__(self, opname):
         pass
 
-    def baseline(self,order,exclude=None,**kwargs):
+    def baseline(self, order, exclude=None, **kwargs):
         """compute and optionally remove a baseline"""
         pass
-
diff --git a/src/dysh/spectra/scan.py b/src/dysh/spectra/scan.py
index d90fa7cf..9ffbd7de 100644
--- a/src/dysh/spectra/scan.py
+++ b/src/dysh/spectra/scan.py
@@ -1,10 +1,13 @@
-import astropy.units as u
 from copy import deepcopy
+
+import astropy.units as u
 import numpy as np
 from astropy.wcs import WCS
-from .spectrum import Spectrum
-from . import mean_tsys, average, veldef_to_convention,tsys_weight
+
 from ..util import sq_weighted_avg
+from . import average, mean_tsys, tsys_weight, veldef_to_convention
+from .spectrum import Spectrum
+
 
 class PSScan(object):
     """
@@ -21,21 +24,22 @@ class PSScan(object):
         bintable : int
             the index for BINTABLE in `sdfits` containing the scans
     """
+
     def __init__(self, sdfits, scans, scanrows, bintable):
-        self._sdfits = sdfits # parent class
-        self._status = 0 #@TODO make these an enumeration, possibly dict
+        self._sdfits = sdfits  # parent class
+        self._status = 0  # @TODO make these an enumeration, possibly dict
         #                           # ex1:
-        self._nint = 0               # 11
-        self._npol = 0               #  2
-        self._on = None              # 44
-        self._off = None             # 44
-        self._calibrated = None      # 22
-        self._timeaveraged = None    #  2
-        self._polaveraged = None     #  1
+        self._nint = 0  # 11
+        self._npol = 0  #  2
+        self._on = None  # 44
+        self._off = None  # 44
+        self._calibrated = None  # 22
+        self._timeaveraged = None  #  2
+        self._polaveraged = None  #  1
         self._bintable_index = bintable
-        self._nrows = len(scanrows['ON'])
+        self._nrows = len(scanrows["ON"])
         print(f"PSSCAN nrows = {self.nrows}")
-        
+
     @property
     def status(self):
         """Status flag, will be used later for undo"""
@@ -51,9 +55,9 @@ def npol(self):
         """The number of polarizations in this Scan"""
         return self._npol
 
-    def timeaverage(self,weights=None):
-        r'''Compute the time-averaged spectrum for this set of scans. 
-        
+    def timeaverage(self, weights=None):
+        r"""Compute the time-averaged spectrum for this set of scans.
+
         Parameters
         ----------
                 weights: str
@@ -66,18 +70,19 @@ def timeaverage(self,weights=None):
         -------
                 spectrum : :class:`~spectra.spectrum.Spectrum`
                     The time-averaged spectrum
-        '''
+        """
         # weights = None (equal) or "tsys"
-        self._timeaveraged = average(self._calibrated,weights=weights)
+        self._timeaveraged = average(self._calibrated, weights=weights)
         # this should really be a spectrum
         return self._timeaveraged
 
-    #@TODO write calibrated data to a FITS? file.
-    #def write(self,filename,format,**kwargs):
+    # @TODO write calibrated data to a FITS? file.
+    # def write(self,filename,format,**kwargs):
 
     def __len__(self):
         return self._nrows
-    
+
+
 class TPScan(object):
     """
     Holds a total power scan
@@ -90,24 +95,25 @@ class TPScan(object):
         sigstate : str
             one of 'SIG' or 'REF' to indicate if this is the signal or reference scan
         scanrows : list-like
-            the list of rows in `sdfits` corresponding to sig_state integrations 
+            the list of rows in `sdfits` corresponding to sig_state integrations
         bintable : int
             the index for BINTABLE in `sdfits` containing the scans
     """
+
     def __init__(self, sdfits, scan, sigstate, calstate, scanrows, bintable):
-        self._sdfits = sdfits # parent class
+        self._sdfits = sdfits  # parent class
         self._scan = scan
         self._sigstate = sigstate
         self._calstate = calstate
         self._scanrows = scanrows
         self._bintable_index = bintable
-        self._data = self._sdfits.rawspectra(bintable)[scanrows] # all cal states
-        self._status = 0 #@TODO make these an enumeration, possibly dict
+        self._data = self._sdfits.rawspectra(bintable)[scanrows]  # all cal states
+        self._status = 0  # @TODO make these an enumeration, possibly dict
         #                           # ex1:
-        self._nint = 0              # 11
-        self._npol = 0              #  2
-        self._timeaveraged = None   #  2
-        self._polaveraged = None    #  1
+        self._nint = 0  # 11
+        self._npol = 0  #  2
+        self._timeaveraged = None  #  2
+        self._polaveraged = None  #  1
         self._nrows = len(scanrows)
         self._tsys = None
         print(f"TPSCAN nrows = {self.nrows}")
@@ -115,14 +121,14 @@ def __init__(self, sdfits, scan, sigstate, calstate, scanrows, bintable):
     @property
     def data(self):
         return self._data
-        
+
     @property
     def scan(self):
         return self._scan
 
-#@TODO all the various attributes should be in a dict. sigstate,calstate,ifnum,plnum etc
-# to make this class flexible. then some sort of clever property accessor.
-#@TODO TPScanList class or let this class contain multiple scans....bookkeeping!
+    # @TODO all the various attributes should be in a dict. sigstate,calstate,ifnum,plnum etc
+    # to make this class flexible. then some sort of clever property accessor.
+    # @TODO TPScanList class or let this class contain multiple scans....bookkeeping!
 
     @property
     def sigstate(self):
@@ -147,17 +153,17 @@ def npol(self):
         """The number of polarizations in this Scan"""
         return self._npol
 
-
     def __len__(self):
         return self._nrows
 
-class GBTTPScan(TPScan): 
+
+class GBTTPScan(TPScan):
     """GBT specific version of Total Power Scan (`~spectra.scan.TPScan`)
 
     Parameters
     ----------
     gbtfits : `~fits.gbtfitsload.GBFITSLoad`
-        input GBFITSLoad object 
+        input GBFITSLoad object
     scan: int
         scan number
     sigstate : str
@@ -165,7 +171,7 @@ class GBTTPScan(TPScan):
     calstate : str
         one of 'ON' or 'OFF' to indicate the calibration state of this scan, or 'BOTH' if it contains both
     scanrows : list-like
-        the list of rows in `sdfits` corresponding to sig_state integrations 
+        the list of rows in `sdfits` corresponding to sig_state integrations
     calrows : dict
         dictionary containing with keys 'ON' and 'OFF' containing list of rows in `sdfits` corresponding to cal=T (ON) and cal=F (OFF) integrations for `scan`
     bintable : int
@@ -173,25 +179,26 @@ class GBTTPScan(TPScan):
     calibrate: bool
         whether or not to calibrate the data.  If `True`, the data will be (calon - caloff)*0.5, otherwise it will be SDFITS row data. Default:True
     """
-#@TODO get rid of calrows and calc tsys in gettp and pass it in.
-    def __init__(self, gbtfits, scan, sigstate, calstate, scanrows, calrows, bintable,calibrate=True):
+
+    # @TODO get rid of calrows and calc tsys in gettp and pass it in.
+    def __init__(self, gbtfits, scan, sigstate, calstate, scanrows, calrows, bintable, calibrate=True):
         TPScan.__init__(self, gbtfits, scan, sigstate, calstate, scanrows, bintable)
         self._calrows = calrows
-        self._npol =  gbtfits.npol(bintable) #TODO deal with bintable
+        self._npol = gbtfits.npol(bintable)  # TODO deal with bintable
         self._nint = gbtfits.nintegrations(bintable)
         self._refonrows = self._calrows["ON"]
         self._refoffrows = self._calrows["OFF"]
         self._refcalon = gbtfits.rawspectra(bintable)[self._refonrows]
         self._refcaloff = gbtfits.rawspectra(bintable)[self._refoffrows]
-        self._calibrate=calibrate
+        self._calibrate = calibrate
         if self._calibrate:
-            self._data = 0.5*(self._refcalon+self._refcaloff)
-        #print(f"# scanrows {len(self._scanrows)}, # calrows ON {len(self._calrows['ON'])}  # calrows OFF {len(self._calrows['OFF'])}")
+            self._data = 0.5 * (self._refcalon + self._refcaloff)
+        # print(f"# scanrows {len(self._scanrows)}, # calrows ON {len(self._calrows['ON'])}  # calrows OFF {len(self._calrows['OFF'])}")
         self.calc_tsys()
 
     @property
     def tsys(self):
-        """The system temperature array. 
+        """The system temperature array.
 
         Returns
         -------
@@ -204,32 +211,30 @@ def calc_tsys(self, **kwargs):
         """
         Calculate the system temperature array
         """
-        kwargs_opts = {
-            'verbose': False
-        }
+        kwargs_opts = {"verbose": False}
         kwargs_opts.update(kwargs)
 
         self._status = 1
 
         tcal = list(self._sdfits.index(self._bintable_index).iloc[self._refonrows]["TCAL"])
         nspect = len(tcal)
-        self._tsys= np.empty(nspect, dtype=float) # should be same as len(calon)
-        #allcal = self._refonrows.copy()
-        #allcal.extend(self._refoffrows)
-        #tcal = list(self._sdfits.index(self._bintable_index).iloc[sorted(allcal)]["TCAL"])
-        #@Todo  this loop could be replaces with clever numpy
-        if len(tcal) != nspect: 
+        self._tsys = np.empty(nspect, dtype=float)  # should be same as len(calon)
+        # allcal = self._refonrows.copy()
+        # allcal.extend(self._refoffrows)
+        # tcal = list(self._sdfits.index(self._bintable_index).iloc[sorted(allcal)]["TCAL"])
+        # @Todo  this loop could be replaces with clever numpy
+        if len(tcal) != nspect:
             raise Exception(f"TCAL length {len(tcal)} and number of spectra {nspect} don't match")
         for i in range(nspect):
-            tsys = mean_tsys(calon=self._refcalon[i],  caloff=self._refcaloff[i],tcal=tcal[i])
+            tsys = mean_tsys(calon=self._refcalon[i], caloff=self._refcaloff[i], tcal=tcal[i])
             self._tsys[i] = tsys
 
     @property
     def exposure(self):
         """Get the array of exposure (integration) times
 
-            exposure =  0.5*(exp_ref_on + exp_ref_off) 
-        
+            exposure =  0.5*(exp_ref_on + exp_ref_off)
+
         Note we only have access to the refon and refoff row indices so can't use sig here.
         This is probably incorrect
 
@@ -238,17 +243,17 @@ def exposure(self):
             exposure : `~numpy.ndarray`
                 The exposure time in units of the EXPOSURE keyword in the SDFITS header
         """
-        exp_ref_on  = self._sdfits.index(self._bintable_index).iloc[self._refonrows]["EXPOSURE"].to_numpy()
+        exp_ref_on = self._sdfits.index(self._bintable_index).iloc[self._refonrows]["EXPOSURE"].to_numpy()
         exp_ref_off = self._sdfits.index(self._bintable_index).iloc[self._refoffrows]["EXPOSURE"].to_numpy()
-        exposure = (exp_ref_on + exp_ref_off)
+        exposure = exp_ref_on + exp_ref_off
         return exposure
 
     @property
     def delta_freq(self):
         """Get the array of channel frequency width
 
-           df =  0.5*(df_ref_on + df_ref_off) 
-        
+           df =  0.5*(df_ref_on + df_ref_off)
+
         Note we only have access to the refon and refoff row indices so can't use sig here.
         This is probably incorrect
 
@@ -259,17 +264,17 @@ def delta_freq(self):
         """
         df_ref_on = self._sdfits.index(self._bintable_index).iloc[self._refonrows]["CDELT1"].to_numpy()
         df_ref_off = self._sdfits.index(self._bintable_index).iloc[self._refoffrows]["CDELT1"].to_numpy()
-        delta_freq = 0.5*(df_ref_on + df_ref_off)
+        delta_freq = 0.5 * (df_ref_on + df_ref_off)
         return delta_freq
 
     @property
     def _tsys_weight(self):
-        r'''The system temperature weighting array computed from current
-        :math:`T_{sys}, t_{exp}`, and `\delta\nu`. See :meth:`tsys_weight` 
-        '''
-        return tsys_weight(self.exposure,self.delta_freq,self.tsys)
+        r"""The system temperature weighting array computed from current
+        :math:`T_{sys}, t_{exp}`, and `\delta\nu`. See :meth:`tsys_weight`
+        """
+        return tsys_weight(self.exposure, self.delta_freq, self.tsys)
 
-    def total_power(self,i):
+    def total_power(self, i):
         """Return the total power spectrum
 
         Parameters
@@ -282,41 +287,54 @@ def total_power(self,i):
             spectrum : `~spectra.spectrum.Spectrum`
         """
         meta = dict(self._sdfits.index(self._bintable_index).iloc[self._scanrows[i]])
-        meta['TSYS'] = self._tsys[i]
-        meta['EXPOSURE'] = self.exposure[i]
+        meta["TSYS"] = self._tsys[i]
+        meta["EXPOSURE"] = self.exposure[i]
         naxis1 = len(self._data[i])
-        ctype1 = meta['CTYPE1']
-        ctype2 = meta['CTYPE2']
-        ctype3 = meta['CTYPE3']
-        crval1 = meta['CRVAL1']
-        crval2 = meta['CRVAL2']
-        crval3 = meta['CRVAL3']
-        crpix1 = meta['CRPIX1']
-        cdelt1 = meta['CDELT1']
-        restfrq = meta['RESTFREQ']
-        if 'CUNIT1' in meta:
-            cunit1 = meta['CUNIT1']
+        meta["CTYPE1"]
+        ctype2 = meta["CTYPE2"]
+        ctype3 = meta["CTYPE3"]
+        crval1 = meta["CRVAL1"]
+        crval2 = meta["CRVAL2"]
+        crval3 = meta["CRVAL3"]
+        crpix1 = meta["CRPIX1"]
+        cdelt1 = meta["CDELT1"]
+        restfrq = meta["RESTFREQ"]
+        if "CUNIT1" in meta:
+            cunit1 = meta["CUNIT1"]
         else:
-            cunit1 = "Hz" #@TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
+            cunit1 = "Hz"  # @TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
         rfq = restfrq * u.Unit(cunit1)
         restfreq = rfq.to("Hz").value
 
-        #@TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
-        wcs = WCS(header={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                          'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfreq,
-                          'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                          'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                          'CUNIT2': 'deg', 'CUNIT3':'deg',
-                          'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1
-                         },
-                  )
-        vc = veldef_to_convention(meta['VELDEF'])
-        s = Spectrum(self._data[i]*u.ct,wcs=wcs,meta=meta,velocity_convention=vc)
+        # @TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
+        wcs = WCS(
+            header={
+                "CDELT1": cdelt1,
+                "CRVAL1": crval1,
+                "CUNIT1": cunit1,
+                "CTYPE1": "FREQ",
+                "CRPIX1": crpix1,
+                "RESTFRQ": restfreq,
+                "CTYPE2": ctype2,
+                "CRVAL2": crval2,
+                "CRPIX2": 1,
+                "CTYPE3": ctype3,
+                "CRVAL3": crval3,
+                "CRPIX3": 1,
+                "CUNIT2": "deg",
+                "CUNIT3": "deg",
+                "NAXIS1": naxis1,
+                "NAXIS2": 1,
+                "NAXIS3": 1,
+            },
+        )
+        vc = veldef_to_convention(meta["VELDEF"])
+        s = Spectrum(self._data[i] * u.ct, wcs=wcs, meta=meta, velocity_convention=vc)
         return s
 
-    def timeaverage(self,weights='tsys'):
-        r'''Compute the time-averaged spectrum for this set of scans. 
-        
+    def timeaverage(self, weights="tsys"):
+        r"""Compute the time-averaged spectrum for this set of scans.
+
         Parameters
         ----------
                 weights: str
@@ -329,51 +347,52 @@ def timeaverage(self,weights='tsys'):
         -------
                 spectrum : :class:`~spectra.spectrum.Spectrum`
                     The time-averaged spectrum
-        '''
+        """
         self._timeaveraged = deepcopy(self.total_power(0))
-        if weights == 'tsys':
+        if weights == "tsys":
             w = self._tsys_weight
         else:
             w = None
-        self._timeaveraged._data = average(self._data,axis=0,weights=w)
-        self._timeaveraged.meta['MEANTSYS'] = np.mean(self._tsys) 
-        self._timeaveraged.meta['WTTSYS'] = sq_weighted_avg(self._tsys,axis=0,weights=w)
-        self._timeaveraged.meta['TSYS'] = self._timeaveraged.meta['WTTSYS']
-        self._timeaveraged.meta['EXPOSURE'] = self.exposure.sum()
+        self._timeaveraged._data = average(self._data, axis=0, weights=w)
+        self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys)
+        self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys, axis=0, weights=w)
+        self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"]
+        self._timeaveraged.meta["EXPOSURE"] = self.exposure.sum()
         return self._timeaveraged
 
-class GBTPSScan(PSScan): # perhaps should derive from TPScan, the only difference is the keys.
+
+class GBTPSScan(PSScan):  # perhaps should derive from TPScan, the only difference is the keys.
     """GBT specific version of Position Switch Scan (PSScan)
 
-       Parameters
-       ----------
-
-       gbtfits : `~fit.gbtfitsload.GBFITSLoad`
-           input GBFITSLoad object 
-       scans : dict
-           dictionary with keys 'ON' and 'OFF' containing unique list of ON (signal) and OFF (reference) scan numbers
-       scanrows : dict
-           dictionary with keys 'ON' and 'OFF' containing the list of rows in `sdfits` corresponding to ON (signal) and OFF (reference) integrations
-       calrows : dict
-           dictionary containing with keys 'ON' and 'OFF' containing list of rows in `sdfits` corresponding to cal=T (ON) and cal=F (OFF) integrations. 
-       bintable : int
-           the index for BINTABLE in `sdfits` containing the scans
+    Parameters
+    ----------
+
+    gbtfits : `~fit.gbtfitsload.GBFITSLoad`
+        input GBFITSLoad object
+    scans : dict
+        dictionary with keys 'ON' and 'OFF' containing unique list of ON (signal) and OFF (reference) scan numbers
+    scanrows : dict
+        dictionary with keys 'ON' and 'OFF' containing the list of rows in `sdfits` corresponding to ON (signal) and OFF (reference) integrations
+    calrows : dict
+        dictionary containing with keys 'ON' and 'OFF' containing list of rows in `sdfits` corresponding to cal=T (ON) and cal=F (OFF) integrations.
+    bintable : int
+        the index for BINTABLE in `sdfits` containing the scans
     """
+
     def __init__(self, gbtfits, scans, scanrows, calrows, bintable=0):
-        PSScan.__init__(self,gbtfits,scans,scanrows,bintable)
+        PSScan.__init__(self, gbtfits, scans, scanrows, bintable)
         # The rows of the original bintable corresponding to ON (sig) and OFF (reg)
         self._scanrows = scanrows
-        #print(f"scanrows ON {self._scanrows['ON']}")
-        #print(f"scanrows OFF {self._scanrows['OFF']}")
-        
+        # print(f"scanrows ON {self._scanrows['ON']}")
+        # print(f"scanrows OFF {self._scanrows['OFF']}")
+
         # calrows perhaps not needed as input since we can get it from gbtfits object?
-        #calrows['ON'] are rows with noise diode was on, regardless of sig or ref
-        #calrows['OFF'] are rows with noise diode was off, regardless of sig or ref
+        # calrows['ON'] are rows with noise diode was on, regardless of sig or ref
+        # calrows['OFF'] are rows with noise diode was off, regardless of sig or ref
         self._calrows = calrows
-        self._npol =  gbtfits.npol(bintable) #TODO deal with bintable
+        self._npol = gbtfits.npol(bintable)  # TODO deal with bintable
         self._nint = gbtfits.nintegrations(bintable)
         # todo use gbtfits.velocity_convention(veldef,velframe)
-        vc = "doppler_radio"
         # so quick with slicing!
         self._sigonrows = sorted(list(set(self._calrows["ON"]).intersection(set(self._scanrows["ON"]))))
         self._sigoffrows = sorted(list(set(self._calrows["OFF"]).intersection(set(self._scanrows["ON"]))))
@@ -396,11 +415,11 @@ def tsys(self):
         """
         return self._tsys
 
-    #TODO something clever 
+    # TODO something clever
     # self._calibrated_spectrum = Spectrum(self._calibrated,...) [assuming same spectral axis]
-    def calibrated(self,i):
+    def calibrated(self, i):
         """Return the calibrated Spectrum.
-        
+
         Parameters
         ----------
             i : int
@@ -411,61 +430,71 @@ def calibrated(self,i):
             spectrum : `~spectra.spectrum.Spectrum`
         """
         meta = dict(self._sdfits.index(self._bintable_index).iloc[self._scanrows["ON"][i]])
-        meta['TSYS'] = self._tsys[i]
+        meta["TSYS"] = self._tsys[i]
         naxis1 = len(self._calibrated[i])
-        ctype1 = meta['CTYPE1']
-        ctype2 = meta['CTYPE2']
-        ctype3 = meta['CTYPE3']
-        crval1 = meta['CRVAL1']
-        crval2 = meta['CRVAL2']
-        crval3 = meta['CRVAL3']
-        crpix1 = meta['CRPIX1']
-        cdelt1 = meta['CDELT1']
-        restfrq = meta['RESTFREQ']
-        if 'CUNIT1' in meta:
-            cunit1 = meta['CUNIT1']
+        meta["CTYPE1"]
+        ctype2 = meta["CTYPE2"]
+        ctype3 = meta["CTYPE3"]
+        crval1 = meta["CRVAL1"]
+        crval2 = meta["CRVAL2"]
+        crval3 = meta["CRVAL3"]
+        crpix1 = meta["CRPIX1"]
+        cdelt1 = meta["CDELT1"]
+        restfrq = meta["RESTFREQ"]
+        if "CUNIT1" in meta:
+            cunit1 = meta["CUNIT1"]
         else:
-            cunit1 = "Hz" #@TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
+            cunit1 = "Hz"  # @TODO this is in gbtfits.hdu[0].header['TUNIT11'] but is it always TUNIT11?
         rfq = restfrq * u.Unit(cunit1)
         restfreq = rfq.to("Hz").value
 
-        #@TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
-        wcs = WCS(header={'CDELT1': cdelt1, 'CRVAL1': crval1, 'CUNIT1': cunit1,
-                                      'CTYPE1': 'FREQ', 'CRPIX1': crpix1, 'RESTFRQ': restfreq,
-                                      'CTYPE2': ctype2, 'CRVAL2': crval2, 'CRPIX2': 1,
-                                      'CTYPE3': ctype3, 'CRVAL3': crval3, 'CRPIX3': 1,
-                                      'CUNIT2': 'deg', 'CUNIT3':'deg',
-                                      'NAXIS1': naxis1, 'NAXIS2':1, 'NAXIS3':1
-                                     },
-                             )
-        vc = veldef_to_convention(meta['VELDEF'])
-        
-        return Spectrum(self._calibrated[i]*u.K,wcs=wcs,meta=meta,velocity_convention=vc)
+        # @TODO WCS is expensive.  Figure how to calculate spectral_axis instead.
+        wcs = WCS(
+            header={
+                "CDELT1": cdelt1,
+                "CRVAL1": crval1,
+                "CUNIT1": cunit1,
+                "CTYPE1": "FREQ",
+                "CRPIX1": crpix1,
+                "RESTFRQ": restfreq,
+                "CTYPE2": ctype2,
+                "CRVAL2": crval2,
+                "CRPIX2": 1,
+                "CTYPE3": ctype3,
+                "CRVAL3": crval3,
+                "CRPIX3": 1,
+                "CUNIT2": "deg",
+                "CUNIT3": "deg",
+                "NAXIS1": naxis1,
+                "NAXIS2": 1,
+                "NAXIS3": 1,
+            },
+        )
+        vc = veldef_to_convention(meta["VELDEF"])
+
+        return Spectrum(self._calibrated[i] * u.K, wcs=wcs, meta=meta, velocity_convention=vc)
 
     def calibrate(self, **kwargs):
         """
         Position switch calibration, following equations 1 and 2 in the GBTIDL clibration manual
         """
-        kwargs_opts = {
-            'verbose': False
-        }
+        kwargs_opts = {"verbose": False}
         kwargs_opts.update(kwargs)
 
         self._status = 1
-        nspect = self.nrows//2
+        nspect = self.nrows // 2
         self._calibrated = np.empty(nspect, dtype=np.ndarray)
-        self._tsys= np.empty(nspect, dtype=float)
+        self._tsys = np.empty(nspect, dtype=float)
 
         tcal = list(self._sdfits.index(self._bintable_index).iloc[self._refonrows]["TCAL"])
-        #@Todo  this loop could be replaced with clever numpy
-        if len(tcal) != nspect: 
+        # @Todo  this loop could be replaced with clever numpy
+        if len(tcal) != nspect:
             raise Exception(f"TCAL length {len(tcal)} and number of spectra {nspect} don't match")
         for i in range(nspect):
-            tsys = mean_tsys(calon=self._refcalon[i],  
-                             caloff=self._refcaloff[i], tcal=tcal[i])
-            sig = 0.5*(self._sigcalon[i] + self._sigcaloff[i])
-            ref = 0.5*(self._refcalon[i] + self._refcaloff[i])
-            self._calibrated[i] = tsys * (sig-ref) / ref
+            tsys = mean_tsys(calon=self._refcalon[i], caloff=self._refcaloff[i], tcal=tcal[i])
+            sig = 0.5 * (self._sigcalon[i] + self._sigcaloff[i])
+            ref = 0.5 * (self._refcalon[i] + self._refcaloff[i])
+            self._calibrated[i] = tsys * (sig - ref) / ref
             self._tsys[i] = tsys
 
     # tip o' the hat to Pedro S. for exposure and delta_freq
@@ -473,55 +502,55 @@ def calibrate(self, **kwargs):
     def exposure(self):
         """Get the array of exposure (integration) times
 
-           exposure = [ 0.5*(exp_ref_on + exp_ref_off) + 0.5*(exp_sig_on + exp_sig_off) ] / 2
-        
-           Returns
-           -------
-                exposure : ~numpy.ndarray
-                    The exposure time in units of the EXPOSURE keyword in the SDFITS header
+        exposure = [ 0.5*(exp_ref_on + exp_ref_off) + 0.5*(exp_sig_on + exp_sig_off) ] / 2
+
+        Returns
+        -------
+             exposure : ~numpy.ndarray
+                 The exposure time in units of the EXPOSURE keyword in the SDFITS header
         """
         exp_ref_on = self._sdfits.index(self._bintable_index).iloc[self._refonrows]["EXPOSURE"].to_numpy()
         exp_ref_off = self._sdfits.index(self._bintable_index).iloc[self._refoffrows]["EXPOSURE"].to_numpy()
         exp_sig_on = self._sdfits.index(self._bintable_index).iloc[self._sigonrows]["EXPOSURE"].to_numpy()
         exp_sig_off = self._sdfits.index(self._bintable_index).iloc[self._sigoffrows]["EXPOSURE"].to_numpy()
-        exp_ref = (exp_ref_on + exp_ref_off)
-        exp_sig = (exp_sig_on + exp_sig_off)
-        #exposure = 0.5*(exp_ref + exp_sig)
-        #exposure = exp_ref + exp_sig
-        nsmooth = 1. # In case we start smoothing the reference spectra.
-        exposure = exp_sig*exp_ref*nsmooth/(exp_sig+exp_ref*nsmooth)
+        exp_ref = exp_ref_on + exp_ref_off
+        exp_sig = exp_sig_on + exp_sig_off
+        # exposure = 0.5*(exp_ref + exp_sig)
+        # exposure = exp_ref + exp_sig
+        nsmooth = 1.0  # In case we start smoothing the reference spectra.
+        exposure = exp_sig * exp_ref * nsmooth / (exp_sig + exp_ref * nsmooth)
         return exposure
 
     @property
     def delta_freq(self):
         """Get the array of channel frequency width
-        
-           df = [ 0.5*(df_ref_on + df_ref_off) + 0.5*(df_sig_on + df_sig_off) ] / 2     
-           
-           Returns
-           -------
-                delta_freq: ~numpy.ndarray
-                    The channel frequency width in units of the CDELT1 keyword in the SDFITS header
+
+        df = [ 0.5*(df_ref_on + df_ref_off) + 0.5*(df_sig_on + df_sig_off) ] / 2
+
+        Returns
+        -------
+             delta_freq: ~numpy.ndarray
+                 The channel frequency width in units of the CDELT1 keyword in the SDFITS header
         """
         df_ref_on = self._sdfits.index(self._bintable_index).iloc[self._refonrows]["CDELT1"].to_numpy()
         df_ref_off = self._sdfits.index(self._bintable_index).iloc[self._refoffrows]["CDELT1"].to_numpy()
         df_sig_on = self._sdfits.index(self._bintable_index).iloc[self._sigonrows]["CDELT1"].to_numpy()
         df_sig_off = self._sdfits.index(self._bintable_index).iloc[self._sigoffrows]["CDELT1"].to_numpy()
-        df_ref = 0.5*(df_ref_on + df_ref_off)
-        df_sig = 0.5*(df_sig_on + df_sig_off)
-        delta_freq = 0.5*(df_ref + df_sig)
+        df_ref = 0.5 * (df_ref_on + df_ref_off)
+        df_sig = 0.5 * (df_sig_on + df_sig_off)
+        delta_freq = 0.5 * (df_ref + df_sig)
         return delta_freq
 
     @property
     def _tsys_weight(self):
-        r'''The system temperature weighting array computed from current
-        :math`T_{sys}`, :math:`t_{int}`, and :math:`\delta\nu`. See :meth:`tsys_weight` 
-        '''
-        return tsys_weight(self.exposure,self.delta_freq,self.tsys)
-
-    def timeaverage(self,weights='tsys'):
-        r'''Compute the time-averaged spectrum for this set of scans. 
-        
+        r"""The system temperature weighting array computed from current
+        :math`T_{sys}`, :math:`t_{int}`, and :math:`\delta\nu`. See :meth:`tsys_weight`
+        """
+        return tsys_weight(self.exposure, self.delta_freq, self.tsys)
+
+    def timeaverage(self, weights="tsys"):
+        r"""Compute the time-averaged spectrum for this set of scans.
+
         Parameters
         ----------
                 weights: str
@@ -534,17 +563,17 @@ def timeaverage(self,weights='tsys'):
         -------
                 spectrum : :class:`~spectra.spectrum.Spectrum`
                     The time-averaged spectrum
-        '''
+        """
         if self._calibrated is None:
             raise Exception("You can't time average before calibration.")
         self._timeaveraged = deepcopy(self.calibrated(0))
         data = self._calibrated
-        if weights == 'tsys':
+        if weights == "tsys":
             w = self._tsys_weight
         else:
             w = None
-        self._timeaveraged._data = average(data,axis=0,weights=w)
-        self._timeaveraged.meta['MEANTSYS'] = np.mean(self._tsys) 
-        self._timeaveraged.meta['WTTSYS'] = sq_weighted_avg(self._tsys,axis=0,weights=w)
-        self._timeaveraged.meta['TSYS'] = self._timeaveraged.meta['WTTSYS']
+        self._timeaveraged._data = average(data, axis=0, weights=w)
+        self._timeaveraged.meta["MEANTSYS"] = np.mean(self._tsys)
+        self._timeaveraged.meta["WTTSYS"] = sq_weighted_avg(self._tsys, axis=0, weights=w)
+        self._timeaveraged.meta["TSYS"] = self._timeaveraged.meta["WTTSYS"]
         return self._timeaveraged
diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py
index 8a7998bb..6cc1b6ee 100644
--- a/src/dysh/spectra/spectrum.py
+++ b/src/dysh/spectra/spectrum.py
@@ -1,13 +1,13 @@
-from specutils import Spectrum1D, SpectrumList,SpectralRegion
-from astropy.modeling.polynomial import Polynomial1D,Chebyshev1D
-from astropy.modeling.fitting import LevMarLSQFitter,LinearLSQFitter
-from astropy.wcs import WCS
-from astropy.io import fits,registry
-from astropy.table import Table
 import astropy.units as u
 import numpy as np
-from . import baseline
+from astropy.io import registry
+from astropy.modeling.fitting import LinearLSQFitter
+from astropy.table import Table
+from specutils import Spectrum1D
+
 from ..plot import specplot as sp
+from . import baseline
+
 
 class Spectrum(Spectrum1D):
     """This class contains a spectrum and its attributes. It is built on
@@ -19,17 +19,18 @@ class Spectrum(Spectrum1D):
 
     *Note:* `velocity_convention` should be one of {'radio', 'optical', 'relativistic'}; the  `~specutils.Spectrum1D` is wrong (there should not be a 'doppler\_' prefix).
     """
-    def __init__(self, *args,**kwargs):
-        Spectrum1D.__init__(self,*args,**kwargs)
+
+    def __init__(self, *args, **kwargs):
+        Spectrum1D.__init__(self, *args, **kwargs)
         # if mask is not set via the flux input (NaNs in flux or flux.mask),
         # then set the mask to all False == good
         if self.mask is None:
-            self._mask = np.full(np.shape(self.flux),False)
+            self._mask = np.full(np.shape(self.flux), False)
         self._baseline_model = None
         self._subtracted = False
         self._exclude_regions = None
         self._plotter = None
-    
+
     @property
     def exclude_regions(self):
         return self._exclude_regions
@@ -46,85 +47,85 @@ def baseline_model(self):
         """Returns the computed baseline model or None if it has not yet been computed."""
         return self._baseline_model
 
-    def baseline(self,degree,exclude=None,**kwargs):
+    def baseline(self, degree, exclude=None, **kwargs):
         """Compute and optionally remove a baseline.  The model for the
-        baseline can be either a 
-        `1D polynomial model <https://docs.astropy.org/en/latest/api/astropy.modeling.polynomial.Polynomial1D.html>`_ or a 
-        `1D Chebyshev polynomial of the first kind <https://docs.astropy.org/en/latest/api/astropy.modeling.polynomial.Chebyshev1D.html>`_.  The code uses `astropy.modeling`
-        and `astropy.fitter` to compute the baseline.  See the documentation for those modules.  This method will set the `baseline_model` attribute to the fitted model function which can be evaluated over a domain.
-        
-        Parameters
-        ----------
-            degree : int
-                The degree of the polynomial series, a.k.a. baseline order
-            exclude : list of 2-tuples of int or ~astropy.units.Quantity, or ~specutils.SpectralRegion
-                List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  
-in channel units.  
-
-                Examples: One channel-based region: [11,51], Two channel-based regions: [(11,51),(99,123)]. One ~astropy.units.Quantity region: [110.198*u.GHz,110.204*u.GHz]. One compound ~specutils.SpectralRegion: SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
-
-                Default: no exclude region
-
-                TODO: Are these OR'd with the existing mask? make that an option
-                TODO: Allow these to be Quantities (spectral axis units or equivalent). See list_to_spectral_region()
-            model : str
-                One of 'polynomial' or 'chebyshev', Default: 'polynomial'
-            fitter  :  `~astropy.fitting._FitterMeta`
-                The fitter to use. Default: `~astropy.fitter.LinearLSQFitter` (with `calc_uncertaintes=True).  Be care when choosing a different fitter to be sure it is optimized for this problem.
-            remove : bool
-                If True, the baseline is removed from the spectrum. Default: False
+                baseline can be either a
+                `1D polynomial model <https://docs.astropy.org/en/latest/api/astropy.modeling.polynomial.Polynomial1D.html>`_ or a
+                `1D Chebyshev polynomial of the first kind <https://docs.astropy.org/en/latest/api/astropy.modeling.polynomial.Chebyshev1D.html>`_.  The code uses `astropy.modeling`
+                and `astropy.fitter` to compute the baseline.  See the documentation for those modules.  This method will set the `baseline_model` attribute to the fitted model function which can be evaluated over a domain.
+
+                Parameters
+                ----------
+                    degree : int
+                        The degree of the polynomial series, a.k.a. baseline order
+                    exclude : list of 2-tuples of int or ~astropy.units.Quantity, or ~specutils.SpectralRegion
+                        List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.
+        in channel units.
+
+                        Examples: One channel-based region: [11,51], Two channel-based regions: [(11,51),(99,123)]. One ~astropy.units.Quantity region: [110.198*u.GHz,110.204*u.GHz]. One compound ~specutils.SpectralRegion: SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
+
+                        Default: no exclude region
+
+                        TODO: Are these OR'd with the existing mask? make that an option
+                        TODO: Allow these to be Quantities (spectral axis units or equivalent). See list_to_spectral_region()
+                    model : str
+                        One of 'polynomial' or 'chebyshev', Default: 'polynomial'
+                    fitter  :  `~astropy.fitting._FitterMeta`
+                        The fitter to use. Default: `~astropy.fitter.LinearLSQFitter` (with `calc_uncertaintes=True).  Be care when choosing a different fitter to be sure it is optimized for this problem.
+                    remove : bool
+                        If True, the baseline is removed from the spectrum. Default: False
         """
         kwargs_opts = {
-            'remove':False,
-            'model':'polynomial',
-            'fitter':  LinearLSQFitter(calc_uncertainties=True),
+            "remove": False,
+            "model": "polynomial",
+            "fitter": LinearLSQFitter(calc_uncertainties=True),
         }
         kwargs_opts.update(kwargs)
 
-        self._baseline_model = baseline(self,degree,exclude,**kwargs)
-        if kwargs_opts['remove']:
-            s=self.subtract(self._baseline_model(self.spectral_axis))
+        self._baseline_model = baseline(self, degree, exclude, **kwargs)
+        if kwargs_opts["remove"]:
+            s = self.subtract(self._baseline_model(self.spectral_axis))
             self._data = s._data
             self._subtracted = True
 
     def _undo_baseline(self):
         """Undo the most recently computed baseline.  If the baseline
-           has been subtracted, it will be added back.  The `baseline_model`
-           attribute is set to None.   Exclude regions are untouched.
+        has been subtracted, it will be added back.  The `baseline_model`
+        attribute is set to None.   Exclude regions are untouched.
         """
         if self._baseline_model is None:
             return
         if self._subtracted:
-            s=self.add(self._baseline_model(self.spectral_axis))
+            s = self.add(self._baseline_model(self.spectral_axis))
             self._data = s._data
             self._baseline_model = None
 
     def _set_exclude_regions(self, exclude):
         """Set the mask for the regions to exclude.
-        
-        Parameters
-        ----------
-            exclude : list of 2-tuples of int or ~astropy.units.Quantity, or ~specutils.SpectralRegion
-                List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.  
-in channel units.  
 
-                Examples: One channel-based region: [11,51], Two channel-based regions: [(11,51),(99,123)]. One ~astropy.units.Quantity region: [110.198*u.GHz,110.204*u.GHz]. One compound ~specutils.SpectralRegion: SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
+                Parameters
+                ----------
+                    exclude : list of 2-tuples of int or ~astropy.units.Quantity, or ~specutils.SpectralRegion
+                        List of region(s) to exclude from the fit.  The tuple(s) represent a range in the form [lower,upper], inclusive.
+        in channel units.
+
+                        Examples: One channel-based region: [11,51], Two channel-based regions: [(11,51),(99,123)]. One ~astropy.units.Quantity region: [110.198*u.GHz,110.204*u.GHz]. One compound ~specutils.SpectralRegion: SpectralRegion([(110.198*u.GHz,110.204*u.GHz),(110.196*u.GHz,110.197*u.GHz)]).
 
         """
         pass
 
-    def list_to_spectral_region(self,inlist):
-        #todo utility code to convert a input list of channels or quantities to a spectral region with units of self.spectral_axis.unit. This could go in core.py
+    def list_to_spectral_region(self, inlist):
+        # todo utility code to convert a input list of channels or quantities to a spectral region with units of self.spectral_axis.unit. This could go in core.py
         # combine this with _set_exclude_regions
         pass
 
     def bshow(self):
-        """Show the baseline model""" 
+        """Show the baseline model"""
         print(f"baseline model {self._baseline_model}")
 
-    def plot(self,**kwargs):
+    def plot(self, **kwargs):
         if self._plotter is None:
-            self._plotter = sp.SpectrumPlot(self,**kwargs)
+            self._plotter = sp.SpectrumPlot(self, **kwargs)
         self._plotter.plot(**kwargs)
 
     @property
@@ -132,14 +133,14 @@ def plotter(self):
         return self._plotter
 
     def stats(self):
-        """ Compute some statistics of this `Spectrum`.  The mean, rms,
+        """Compute some statistics of this `Spectrum`.  The mean, rms,
         data minimum and data maximum are calculated.  Note this works
         with slicing, so, e.g.,  `myspectrum[45:153].stats()` will return
-        the statistics of the slice.  
+        the statistics of the slice.
 
         Returns
         -------
-        stats : tuple 
+        stats : tuple
             Tuple consisting of (mean,rms,datamin,datamax)
             TODO: maybe make this a dict
         """
@@ -147,56 +148,50 @@ def stats(self):
         rms = self.data.std()
         dmin = self.min()
         dmax = self.max()
-        return (mean,rms,dmin,dmax)
+        return (mean, rms, dmin, dmax)
 
     def smooth(self):
-        #todo use specutils.manipulation.smoothing
-        #option to smooth baseline too?
+        # todo use specutils.manipulation.smoothing
+        # option to smooth baseline too?
         pass
 
-
     @property
     def equivalencies(self):
         # @todo encapsulate take into account velframe and veldef
         """Get the spectral axis equivalencies that can be used in converting the axis between km/s and frequency or wavelength"""
         equiv = u.spectral()
-        sa  = self.spectral_axis
-        convention=self.velocity_convention
+        sa = self.spectral_axis
         if sa.doppler_rest is not None:
             rfq = sa.doppler_rest
         elif "RESTFREQ" in self.meta:
-            cunit1 = self.meta.get("CUNIT1",self.wcs.wcs.cunit[0])
-            #@todo this could be done with a dict str->function
-            rfq = self.meta["RESTFREQ"]*cunit1
+            cunit1 = self.meta.get("CUNIT1", self.wcs.wcs.cunit[0])
+            # @todo this could be done with a dict str->function
+            rfq = self.meta["RESTFREQ"] * cunit1
         else:
             rfq = None
-        #print("RESTFREQ is ",rfq)
+        # print("RESTFREQ is ",rfq)
         if rfq is not None:
             if "radio" in self.velocity_convention:
                 # Yeesh, the doppler_convention parameter for SpectralAxis.to does not match the doppler_convention list for Spectrum1D!
-# This is actually bug in Spectrum1D documentation https://github.com/astropy/specutils/issues/1067
-                convention="radio"
+                # This is actually bug in Spectrum1D documentation https://github.com/astropy/specutils/issues/1067
                 equiv.extend(u.doppler_radio(rfq))
             elif "optical" in self.velocity_convention:
-                convention="optical"
                 equiv.extend(u.doppler_optical(rfq))
             elif "relativistic" in self.velocity_convention:
-                convention="relativistic"
                 equiv.extend(u.doppler_relativistic(rfq))
             elif "redshift" in self.velocity_convention:
-                convention="redshift"
                 equiv.extend(u.doppler_redshift())
         return equiv
 
-    def savefig(self,file,**kwargs):
+    def savefig(self, file, **kwargs):
         """Save the plot"""
         if self._plotter is None:
             raise Exception("You have to invoke plot() first")
-        self._plotter.figure.savefig(file,**kwargs)
+        self._plotter.figure.savefig(file, **kwargs)
 
-    def _write_table(self,fileobj,format,**kwargs):
+    def _write_table(self, fileobj, format, **kwargs):
         """Write this `Spectrum` as an ~astropy.table.Table.
-        
+
         Parameters
         ----------
         fileobj : str, file-like or `pathlib.Path`
@@ -207,19 +202,18 @@ def _write_table(self,fileobj,format,**kwargs):
         kwargs : variable
             Additional keyword arguments supported by ~astropy.table.Table.write
         """
-                
+
         flux = self.flux
         axis = self.spectral_axis
         mask = self.mask
-        t = Table([axis, flux, mask],
-                  names=["spectral_axis", "flux", "mask"],
-                  meta = self.meta)
+        t = Table([axis, flux, mask], names=["spectral_axis", "flux", "mask"], meta=self.meta)
         if self.uncertainty is not None:
             t.add_column(self.uncertainty._array, name="uncertainty")
-        #f=kwargs.pop("format")
-        t.write(fileobj,format=format,**kwargs)
+        # f=kwargs.pop("format")
+        t.write(fileobj, format=format, **kwargs)
+
 
-#@TODO figure how how to document write()
+# @TODO figure how how to document write()
 ####################################################################
 # There is probably a less brute-force way to do this but I haven't
 # been able to figure it out.  astropy.io.registry tools are not
@@ -227,24 +221,33 @@ def _write_table(self,fileobj,format,**kwargs):
 # it cannot be passed along via a single overaarching write method,
 # e.g., spectrum_writer()
 ####################################################################
-def ascii_spectrum_writer_basic(spectrum,fileobj,**kwargs):
-    spectrum._write_table(fileobj,format='ascii.basic',**kwargs)
-def ascii_spectrum_writer_commented_header(spectrum,fileobj,**kwargs):
-    spectrum._write_table(fileobj,format='ascii.commented_header',**kwargs)
-def ascii_spectrum_writer_fixed_width(spectrum,fileobj,**kwargs):
-    spectrum._write_table(fileobj,format='ascii.fixed_width',**kwargs)
-def ascii_spectrum_writer_ipac(spectrum,fileobj,**kwargs):
-    spectrum._write_table(fileobj,format='ascii.ipac',**kwargs)
-def spectrum_writer_votable(spectrum,fileobj,**kwargs):
-    spectrum._write_table(fileobj,format='votable',**kwargs)
+def ascii_spectrum_writer_basic(spectrum, fileobj, **kwargs):
+    spectrum._write_table(fileobj, format="ascii.basic", **kwargs)
+
+
+def ascii_spectrum_writer_commented_header(spectrum, fileobj, **kwargs):
+    spectrum._write_table(fileobj, format="ascii.commented_header", **kwargs)
+
+
+def ascii_spectrum_writer_fixed_width(spectrum, fileobj, **kwargs):
+    spectrum._write_table(fileobj, format="ascii.fixed_width", **kwargs)
+
+
+def ascii_spectrum_writer_ipac(spectrum, fileobj, **kwargs):
+    spectrum._write_table(fileobj, format="ascii.ipac", **kwargs)
+
+
+def spectrum_writer_votable(spectrum, fileobj, **kwargs):
+    spectrum._write_table(fileobj, format="votable", **kwargs)
+
 
 with registry.delay_doc_updates(Spectrum):
-    registry.register_writer('ascii.basic', Spectrum, ascii_spectrum_writer_basic)
-    registry.register_writer('basic', Spectrum, ascii_spectrum_writer_basic)
-    registry.register_writer('ascii.commented_header', Spectrum, ascii_spectrum_writer_commented_header)
-    registry.register_writer('commented_header', Spectrum, ascii_spectrum_writer_commented_header)
-    registry.register_writer('ascii.fixed_width', Spectrum, ascii_spectrum_writer_fixed_width)
-    registry.register_writer('fixed_width', Spectrum, ascii_spectrum_writer_fixed_width)
-    registry.register_writer('ascii.ipac', Spectrum, ascii_spectrum_writer_ipac)
-    registry.register_writer('ipac', Spectrum, ascii_spectrum_writer_ipac)
-    registry.register_writer('votable', Spectrum, spectrum_writer_votable)
+    registry.register_writer("ascii.basic", Spectrum, ascii_spectrum_writer_basic)
+    registry.register_writer("basic", Spectrum, ascii_spectrum_writer_basic)
+    registry.register_writer("ascii.commented_header", Spectrum, ascii_spectrum_writer_commented_header)
+    registry.register_writer("commented_header", Spectrum, ascii_spectrum_writer_commented_header)
+    registry.register_writer("ascii.fixed_width", Spectrum, ascii_spectrum_writer_fixed_width)
+    registry.register_writer("fixed_width", Spectrum, ascii_spectrum_writer_fixed_width)
+    registry.register_writer("ascii.ipac", Spectrum, ascii_spectrum_writer_ipac)
+    registry.register_writer("ipac", Spectrum, ascii_spectrum_writer_ipac)
+    registry.register_writer("votable", Spectrum, spectrum_writer_votable)
diff --git a/src/dysh/spectra/tests/test_core.py b/src/dysh/spectra/tests/test_core.py
index fe28c060..5b399236 100644
--- a/src/dysh/spectra/tests/test_core.py
+++ b/src/dysh/spectra/tests/test_core.py
@@ -1,43 +1,36 @@
-
 import os
-import pytest
-import numpy as np
 
+import numpy as np
+import pytest
 from astropy.io import fits
-from astropy.utils.data import (
-                    get_pkg_data_filename,
-                    )
-
 from dysh.spectra import core
 
-
 LOCALDIR = os.path.dirname(os.path.realpath(__file__))
 
 
-class TestMeanTsys():
+class TestMeanTsys:
     """
     Tests for `dysh.spectra.core.dcmeantsys` function.
     """
 
     def test_tsys(self):
-
         expected = np.array([17.24000345, 17.17140405, 17.15663698])
 
         path_to_file = "../../fits/tests/data"
         filename = "TGBT21A_501_11_ifnum_0_int_0-2.fits"
-        sdf_file = f"{LOCALDIR}/{path_to_file}/{filename}" 
-        #get_pkg_data_filename(f"{path_to_file}/{filename}")
+        sdf_file = f"{LOCALDIR}/{path_to_file}/{filename}"
+        # get_pkg_data_filename(f"{path_to_file}/{filename}")
 
         # Open and select data.
         hdu_sdf = fits.open(sdf_file)
         table = hdu_sdf[1].data
-        table_pl0 = table[table["PLNUM"]==0]
-        table_pl0_off = table_pl0[table_pl0["SCAN"]==153]
+        table_pl0 = table[table["PLNUM"] == 0]
+        table_pl0_off = table_pl0[table_pl0["SCAN"] == 153]
         tcal = table_pl0_off["TCAL"][0]
-        tsys_dysh = np.empty(table_pl0_off["DATA"].shape[0]//2, dtype=float)
+        tsys_dysh = np.empty(table_pl0_off["DATA"].shape[0] // 2, dtype=float)
         for i in range(len(tsys_dysh)):
-            tsys_dysh[i] = core.mean_tsys(calon=table_pl0_off["DATA"][1::2][i],  
-                                         caloff=table_pl0_off["DATA"][0::2][i],
-                                         tcal=tcal)
+            tsys_dysh[i] = core.mean_tsys(
+                calon=table_pl0_off["DATA"][1::2][i], caloff=table_pl0_off["DATA"][0::2][i], tcal=tcal
+            )
         # Compare.
         assert tsys_dysh == pytest.approx(expected)
diff --git a/src/dysh/spectra/tests/test_scan.py b/src/dysh/spectra/tests/test_scan.py
index 94e2ef5d..e7a9308c 100644
--- a/src/dysh/spectra/tests/test_scan.py
+++ b/src/dysh/spectra/tests/test_scan.py
@@ -1,27 +1,20 @@
-
-import pytest
-import pathlib
 import numpy as np
-
 from astropy.io import fits
 from astropy.utils.data import (
-                            get_pkg_data_filename,
-                            )
-
-import dysh
+    get_pkg_data_filename,
+)
 from dysh.fits import gbtfitsload
 
-#dysh_root = pathlib.Path(dysh.__file__).parent.resolve()
+# dysh_root = pathlib.Path(dysh.__file__).parent.resolve()
 
-class TestGBTPSScan():
 
+class TestGBTPSScan:
     def test_compare_with_GBTIDL(self):
-
         # get filenames
         sdf_file = get_pkg_data_filename("data/TGBT21A_501_11_ifnum_0_int_0-2.fits")
         gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits")
-        #sdf_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_ifnum_0_int_0-2.fits"
-        #gbtidl_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits"
+        # sdf_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_ifnum_0_int_0-2.fits"
+        # gbtidl_file = f"{dysh_root}/fits/tests/data/TGBT21A_501_11_ifnum_0_int_0-2_getps_152_plnum_0.fits"
 
         # Generate the dysh result.
         sdf = gbtfitsload.GBTFITSLoad(sdf_file)
@@ -37,8 +30,8 @@ def test_compare_with_GBTIDL(self):
         diff = psscan_tavg.flux.value - psscan_gbtidl
         assert np.nanmedian(diff) == 0.0
 
-class TestSubBeamNod():
 
+class TestSubBeamNod:
     def test_compare_with_GBTIDL(self):
         # get filenames
         # We still need a data file with a single scan in it
@@ -48,31 +41,28 @@ def test_compare_with_GBTIDL(self):
         # Generate the dysh result.
         # snodka-style. Need test for method='cycle'
         sdf = gbtfitsload.GBTFITSLoad(sdf_file)
-        sbn = sdf.subbeamnod(43, sig=None, cal=None,
-                        ifnum=0, fdnum=1, calibrate=True,
-                        weights='tsys',method='scan') 
+        sbn = sdf.subbeamnod(43, sig=None, cal=None, ifnum=0, fdnum=1, calibrate=True, weights="tsys", method="scan")
 
         # Load the GBTIDL result.
         hdu = fits.open(gbtidl_file)
         nodscan_gbtidl = hdu[1].data["DATA"][0]
 
         # Compare.
-        ratio = sbn.flux.value/nodscan_gbtidl
-        #print("DIFF ",np.nanmedian(sbn.flux.value - nodscan_gbtidl))
-        # kluge for now since there is a small wavy pattern in 
+        ratio = sbn.flux.value / nodscan_gbtidl
+        # print("DIFF ",np.nanmedian(sbn.flux.value - nodscan_gbtidl))
+        # kluge for now since there is a small wavy pattern in
         # the difference at the ~0.06 K level
         assert np.nanmedian(ratio) <= 0.998
 
-class TestGBTTPScan():
 
+class TestGBTTPScan:
     def test_compare_with_GBTIDL_tsys_weights(self):
-
         sdf_file = get_pkg_data_filename("data/TGBT21A_501_11_scan_152_ifnum_0_plnum_0.fits")
         gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0_keepints.fits")
 
         # Generate the dysh result.
         sdf = gbtfitsload.GBTFITSLoad(sdf_file)
-        tp  = sdf.gettp(152)
+        tp = sdf.gettp(152)
         tpavg = tp.timeaverage()
 
         # Check that we know how to add.
@@ -93,18 +83,17 @@ def test_compare_with_GBTIDL_tsys_weights(self):
         assert abs(tpavg.meta["TSYS"] - table["TSYS"][-1]) < 1e-10
         # Data, which uses float -- 32 bits.
         assert np.sum(tp._data - data[:-1]) == 0.0
-        assert np.nanmean((tpavg.flux.value - data[-1])/data[-1].mean()) < 2**32
-        
-    def test_compare_with_GBTIDL_equal_weights(self):
+        assert np.nanmean((tpavg.flux.value - data[-1]) / data[-1].mean()) < 2**32
 
+    def test_compare_with_GBTIDL_equal_weights(self):
         sdf_file = get_pkg_data_filename("data/TGBT21A_501_11_scan_152_ifnum_0_plnum_0.fits")
         gbtidl_file = get_pkg_data_filename("data/TGBT21A_501_11_gettp_scan_152_ifnum_0_plnum_0_eqweight.fits")
 
         # Generate the dysh result.
         sdf = gbtfitsload.GBTFITSLoad(sdf_file)
-        tp  = sdf.gettp(152)
+        tp = sdf.gettp(152)
         tpavg = tp.timeaverage(weights=None)
-        
+
         # Check that we know how to add.
         assert tpavg.meta["EXPOSURE"] == tp.exposure.sum()
 
@@ -117,4 +106,3 @@ def test_compare_with_GBTIDL_equal_weights(self):
         assert table["EXPOSURE"][0] == tpavg.meta["EXPOSURE"]
         assert abs(table["TSYS"][0] - tpavg.meta["TSYS"]) < 2**-32
         assert np.all((data[0] - tpavg.flux.value) == 0.0)
-
diff --git a/src/dysh/util/core.py b/src/dysh/util/core.py
index d00a1605..9c7c5a99 100644
--- a/src/dysh/util/core.py
+++ b/src/dysh/util/core.py
@@ -7,7 +7,7 @@
 
 def consecutive(data, stepsize=1):
     """Returns the indices of elements in `data`
-    separated by less than stepsize separated into 
+    separated by less than stepsize separated into
     groups.
 
     Parameters
@@ -23,12 +23,12 @@ def consecutive(data, stepsize=1):
     groups : `~numpy.ndarray`
         Array with values of `data` separated into groups.
     """
-    return np.split(data, np.where(np.diff(data) >= stepsize)[0]+1)
+    return np.split(data, np.where(np.diff(data) >= stepsize)[0] + 1)
 
 
-def sq_weighted_avg(a,axis=0,weights=None):
-#@todo make a generic moment or use scipy.stats.moment
-    r'''Compute the mean square weighted average of an array (2nd moment).
+def sq_weighted_avg(a, axis=0, weights=None):
+    # @todo make a generic moment or use scipy.stats.moment
+    r"""Compute the mean square weighted average of an array (2nd moment).
 
     :math:`v = \sqrt{\frac{\sum_i{w_i~a_i^{2}}}{\sum_i{w_i}}}`
 
@@ -47,12 +47,12 @@ def sq_weighted_avg(a,axis=0,weights=None):
     -------
     average : `~numpy.ndarray`
         The average along the input axis
-    '''
+    """
     if weights is None:
-        w = np.ones_like(a)
+        np.ones_like(a)
     else:
-        w = weights
-    v = np.sqrt(np.average(a*a,axis=axis,weights=weights))
+        pass
+    v = np.sqrt(np.average(a * a, axis=axis, weights=weights))
     return v
 
 
@@ -72,38 +72,41 @@ def get_size(obj, seen=None):
     if isinstance(obj, dict):
         size += sum([get_size(v, seen) for v in obj.values()])
         size += sum([get_size(k, seen) for k in obj.keys()])
-    elif hasattr(obj, '__dict__'):
+    elif hasattr(obj, "__dict__"):
         size += get_size(obj.__dict__, seen)
-    elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)):
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes, bytearray)):
         size += sum([get_size(i, seen) for i in obj])
     return size
 
-def minimum_string_match(s,valid_strings):
+
+def minimum_string_match(s, valid_strings):
     """return the valid string given a minimum string input"""
     pass
 
+
 def stripTable(table):
-    '''Remove leading and trailing chars from all strings from an input table.
-        
-       Parameters
-       ----------
-        table: ~astropy.table.Table
-            The table to strip
-    '''
+    """Remove leading and trailing chars from all strings from an input table.
+
+    Parameters
+    ----------
+     table: ~astropy.table.Table
+         The table to strip
+    """
     for n in table.colnames:
-        if np.issubdtype(table.dtype[n],str):
+        if np.issubdtype(table.dtype[n], str):
             table[n] = np.char.strip(table[n])
 
-#def strip(self,tables):
+
+# def strip(self,tables):
 #    '''remove leading and trailing chars from all strings in list of tables'''
 #    for b in tables:
 #        stripTable(b)
 
+
 def uniq(seq):
-    """ Remove duplicates from a list while preserving order.
-        from http://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-python-whilst-preserving-order 
+    """Remove duplicates from a list while preserving order.
+    from http://stackoverflow.com/questions/480214/how-do-you-remove-duplicates-from-a-list-in-python-whilst-preserving-order
     """
     seen = set()
     seen_add = seen.add
-    return [ x for x in seq if x not in seen and not seen_add(x)]
-
+    return [x for x in seq if x not in seen and not seen_add(x)]
diff --git a/src/dysh/util/files.py b/src/dysh/util/files.py
index 86ecbed7..cc3d05b0 100755
--- a/src/dysh/util/files.py
+++ b/src/dysh/util/files.py
@@ -11,14 +11,13 @@
 #  find . -name \*$a\* -print
 
 
-import os
-import sys
 import glob
+import os
 
 _debug = True
 
 
-#def find_data_recursively(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
+# def find_data_recursively(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
 def fdr(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
     """
     Input:
@@ -34,10 +33,10 @@ def fdr(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
         Note if multiple paths are given,  maxfiles is applied to each sublist
 
     See also:
-        astropy's getdata ???  
+        astropy's getdata ???
         pdrptry.pdrutils.get_testdata()
         astropy.utils.data.get_pkg_data_filenames
-    
+
     Examples:
         fdr('ngc1234.fits')    - this exact file!
         fdr('*.fits')          - all fits file in this directory
@@ -50,28 +49,28 @@ def fdr(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
     if os.path.exists(filename):
         return [filename]
 
-    if path == None:
+    if path is None:
         if wildcard:
-            fname = '*' + filename + '*'
+            fname = "*" + filename + "*"
         else:
             fname = filename
         if recursive:
-            fname = '**/' + fname
+            fname = "**/" + fname
         if _debug:
-            print('# FNAME:',fname)
-            
+            print("# FNAME:", fname)
+
         fn = glob.glob(fname, recursive=recursive)
 
-        if maxfiles == None:
+        if maxfiles is None:
             retval = fn
         else:
             retval = fn[:maxfiles]
         retval.sort()
     else:
         cwd0 = os.getcwd()
-        all=[]
-        for p in path.split(':'):
-            if p[0] == '$':
+        all = []
+        for p in path.split(":"):
+            if p[0] == "$":
                 if p[1:] in os.environ:
                     p = os.environ[p[1:]]
                 else:
@@ -79,14 +78,14 @@ def fdr(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
             if os.path.exists(p):
                 os.chdir(p)
                 if wildcard:
-                    fname = '*' + filename + '*'
+                    fname = "*" + filename + "*"
                 else:
                     fname = filename
                 if recursive:
-                    fname = '**/' + fname
+                    fname = "**/" + fname
                 fn = glob.glob(fname, recursive=recursive)
                 fn.sort()
-                if maxfiles != None:
+                if maxfiles is not None:
                     fn = fn[:maxfiles]
                 all = all + fn
             else:
@@ -95,8 +94,8 @@ def fdr(filename, path=None, recursive=False, wildcard=False, maxfiles=None):
         retval = all
     return retval
 
-def main_cli():
 
+def main_cli():
     import argparse
 
     my_help = """
@@ -109,18 +108,17 @@ def main_cli():
 
     """
 
-    p = argparse.ArgumentParser(description=my_help, epilog='And so the search goes on....')
-    p.add_argument('-m', '--maxfiles', type = int, default = None, help='Maximum number of files to return [Default: all]')
-    p.add_argument('-c', '--count', action='store_true',           help='add counter to filenames?')
-    p.add_argument('-w', '--wildcard', action='store_true',        help='fully wildcard the filename embedded')
-    p.add_argument('-r', '--recursive', action='store_true',       help='resursive?')
-    p.add_argument('-p', '--path', type = str, default = None,     help='optional (colon separated) path(s)')
-    p.add_argument('filename', nargs='+',                          help='Filename(s) to search for')
-
+    p = argparse.ArgumentParser(description=my_help, epilog="And so the search goes on....")
+    p.add_argument("-m", "--maxfiles", type=int, default=None, help="Maximum number of files to return [Default: all]")
+    p.add_argument("-c", "--count", action="store_true", help="add counter to filenames?")
+    p.add_argument("-w", "--wildcard", action="store_true", help="fully wildcard the filename embedded")
+    p.add_argument("-r", "--recursive", action="store_true", help="resursive?")
+    p.add_argument("-p", "--path", type=str, default=None, help="optional (colon separated) path(s)")
+    p.add_argument("filename", nargs="+", help="Filename(s) to search for")
 
     args = p.parse_args()
     if _debug:
-        print('#', args)
+        print("#", args)
 
     filename = args.filename
     maxfiles = args.maxfiles
@@ -132,13 +130,13 @@ def main_cli():
     r = []
     for f in filename:
         r = r + fdr(f, path, recursive, wildcard, maxfiles)
-    # r.sort()    
+    # r.sort()
 
     if count:
-        n=1
+        n = 1
         for f in r:
-            print(n,f)
-            n=n+1
+            print(n, f)
+            n = n + 1
     else:
         for f in r:
             print(f)
@@ -146,4 +144,3 @@ def main_cli():
 
 if __name__ == "__main__":
     main_cli()
-            
diff --git a/src/dysh/util/tests/test_wget.py b/src/dysh/util/tests/test_wget.py
index bbd63dfd..5132bb87 100644
--- a/src/dysh/util/tests/test_wget.py
+++ b/src/dysh/util/tests/test_wget.py
@@ -1,10 +1,12 @@
-import wget
 import os
 
+import wget
+
+
 def test_flag_wget():
     url = "https://www.gb.nrao.edu/dysh/example_data/nod-KFPA/data/TGBT22A_503_02.raw.vegas/TGBT22A_503_02.raw.vegas.A.flag"
     try:
         fname = wget.download(url)
         os.remove(fname)
     except Exception as exc:
-        assert False, f"test_flag_wget raised the following exception: {exc}"
\ No newline at end of file
+        assert False, f"test_flag_wget raised the following exception: {exc}"

From c5eeb836ecfeb8a87ab02fd289cc00c1469dc76e Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 14:48:10 -0400
Subject: [PATCH 06/12] Fix invalid escape sequences

---
 src/dysh/plot/specplot.py    | 8 ++++----
 src/dysh/spectra/spectrum.py | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/dysh/plot/specplot.py b/src/dysh/plot/specplot.py
index 77216e2f..1ccb5444 100644
--- a/src/dysh/plot/specplot.py
+++ b/src/dysh/plot/specplot.py
@@ -9,7 +9,7 @@ class SpectrumPlot:
     """
     The SpectrumPlot class is for simple plotting of a ~spectrum.Spectrum
     using matplotlib functions.   Plots attributes are modified using keywords
-    (\*\*kwargs) described below SpectrumPlot will attempt to make smart default
+    (\\*\\*kwargs) described below SpectrumPlot will attempt to make smart default
     choices for the plot if no additional keywords are given.
     The attributes are "sticky" meaning that an attribute set via
     instantiation or by the `plot()` method will stay set until changed
@@ -19,7 +19,7 @@ class SpectrumPlot:
     ----------
     spectrum : `~spectra.spectrum.Spectrum`
         The spectrum to plot
-    \**kwargs : dict
+    \\**kwargs : dict
         Plot attribute keyword arguments, see below.
 
     Keyword Arguments
@@ -92,7 +92,7 @@ def plot(self, **kwargs):
 
         Parameters
         ----------
-        \**kwargs : various
+        \\**kwargs : various
             keyword=value arguments (need to describe these in a central place)
         """
         # xtype = 'velocity, 'frequency', 'wavelength'
@@ -173,7 +173,7 @@ def _set_labels(self, title=None, xlabel=None, ylabel=None, **kwargs):
             x-axis label
         ylabel : str
             x-axis label
-        \*\*kwargs : various
+        \\*\\*kwargs : various
             other keyword=value arguments
         """
         if title is not None:
diff --git a/src/dysh/spectra/spectrum.py b/src/dysh/spectra/spectrum.py
index 6cc1b6ee..db456795 100644
--- a/src/dysh/spectra/spectrum.py
+++ b/src/dysh/spectra/spectrum.py
@@ -17,7 +17,7 @@ class Spectrum(Spectrum1D):
     have only one spectral axis conflicts with slight Doppler shifts.
     See `~specutils.Spectrum1D` for the instantiation arguments.
 
-    *Note:* `velocity_convention` should be one of {'radio', 'optical', 'relativistic'}; the  `~specutils.Spectrum1D` is wrong (there should not be a 'doppler\_' prefix).
+    *Note:* `velocity_convention` should be one of {'radio', 'optical', 'relativistic'}; the  `~specutils.Spectrum1D` is wrong (there should not be a 'doppler\\_' prefix).
     """
 
     def __init__(self, *args, **kwargs):

From 5bc5295ea4c2abc283a99a2a716cbc1e80394b71 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 14:55:02 -0400
Subject: [PATCH 07/12] Fix a few linting errors

Tweak a few linting settings
---
 .pre-commit-config.yaml | 2 +-
 pyproject.toml          | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c4ff46f2..6dc9e618 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -29,7 +29,7 @@ repos:
         - '--fix'
         - '--exit-non-zero-on-fix'
         - '--select=F,E,B,I'
-        - '--ignore=E501'
+        - '--ignore=E501'  # Ignore line-too-long errors; these are only long comment lines
 
   - repo: 'https://github.com/psf/black'
     rev: 23.7.0
diff --git a/pyproject.toml b/pyproject.toml
index eb0ebbb8..11cec08b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -133,15 +133,16 @@ select = [
 fixable = ["ALL"]
 unfixable = ["B"]
 ignore = [
-  "E501",  # Ignore line length violations
+  "E741",  # ambiguous-variable-name
 ]
 line-length = 120
 
-# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
 [tool.ruff.per-file-ignores]
-"__init__.py" = ["E402"]
-"path/to/file.py" = ["E402"]
+# Ignore  in all `__init__.py` files
+"__init__.py" = ["E402", "F405", "F403"]
 "**/{tests,docs,tools}/*" = ["E402", "B011"]
+# The stuff in the attic doesn't need to be linted at all
+"attic/**" = ["ALL"]
 
 [tool.pytest.ini_options]
 minversion = "6.0"

From 69fd204fe0cec7c44b679b852a8caac9812a087f Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:12:02 -0400
Subject: [PATCH 08/12] Add pre-commit GitHub action

---
 .github/workflows/pre-commit.yml | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 .github/workflows/pre-commit.yml

diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
new file mode 100644
index 00000000..e063b135
--- /dev/null
+++ b/.github/workflows/pre-commit.yml
@@ -0,0 +1,17 @@
+name: pre-commit
+
+on:
+  pull_request:
+  push:
+    branches: [main, release*]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+      with:
+        # must match the version in .pre-commit-config.yaml:default_language_version.python
+        python-version: '3.9'
+    - uses: pre-commit/action@v3.0.0

From 356cb9e605c2eeee91642a8b2fce92876ea09c0e Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:18:01 -0400
Subject: [PATCH 09/12] Don't emit trusted host in pip-compile

---
 .pre-commit-config.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6dc9e618..7a5b7ca3 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -48,3 +48,4 @@ repos:
           - '--output-file=requirements.txt'
           - '--no-strip-extras'
           - '--quiet'
+          - '--no-emit-trusted-host'

From a3995c174601b48ce361f71a5628c3f6c256f7e9 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:21:36 -0400
Subject: [PATCH 10/12] Remove trusted host line from requirements.txt

Disable ruff pre-commit hook in github action, since it is currently
failing
---
 .github/workflows/pre-commit.yml | 3 +++
 requirements.txt                 | 4 +---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index e063b135..3e5f8cc2 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -5,8 +5,11 @@ on:
   push:
     branches: [main, release*]
 
+
 jobs:
   pre-commit:
+    env:
+      SKIP: ruff
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
diff --git a/requirements.txt b/requirements.txt
index 1e10f731..2f76d8e6 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,10 +2,8 @@
 # This file is autogenerated by pip-compile with Python 3.9
 # by the following command:
 #
-#    pip-compile --all-extras --output-file=requirements.txt pyproject.toml
+#    pip-compile --all-extras --no-emit-trusted-host --output-file=requirements.txt pyproject.toml
 #
---trusted-host pypi.gb.nrao.edu
-
 alabaster==0.7.13
     # via sphinx
 asdf==2.15.1

From 565aa7957704331bb34886e054e66e94eca304bf Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:55:09 -0400
Subject: [PATCH 11/12] Disable ruff pre-commit hook

It's currently failing due to issues that I'm not qualified to fix

Also, merged docs and dev in optional-dependencies

Renamed matrix test runner
---
 .pre-commit-config.yaml | 20 ++++++++++----------
 pyproject.toml          |  4 +---
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 7a5b7ca3..729c6610 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -20,16 +20,16 @@ repos:
         args:
           - '--fix=lf'
 
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.285
-    hooks:
-    - id: ruff
-      alias: autoformat
-      args:
-        - '--fix'
-        - '--exit-non-zero-on-fix'
-        - '--select=F,E,B,I'
-        - '--ignore=E501'  # Ignore line-too-long errors; these are only long comment lines
+  # - repo: https://github.com/astral-sh/ruff-pre-commit
+  #   rev: v0.0.285
+  #   hooks:
+  #   - id: ruff
+  #     alias: autoformat
+  #     args:
+  #       - '--fix'
+  #       - '--exit-non-zero-on-fix'
+  #       - '--select=F,E,B,I'
+  #       - '--ignore=E501'  # Ignore line-too-long errors; these are only long comment lines
 
   - repo: 'https://github.com/psf/black'
     rev: 23.7.0
diff --git a/pyproject.toml b/pyproject.toml
index 11cec08b..c2abf11a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -39,8 +39,6 @@ dev = [
   "pytest",
   "pytest-cov",
   "wget",
-]
-docs = [
   "myst-parser",
   "sphinx",
   "sphinx-autobuild",
@@ -77,7 +75,7 @@ docs-build = "sphinx-build {root}/docs {root}/docs/build -b html {args}"
 
 # run via: $ hatch run test:<script>
 [tool.hatch.envs.test.scripts]
-run = "pytest {args}"
+matrix = "pytest {args}"
 cov = "pytest --cov-report=term-missing --cov-config=pyproject.toml --cov=src/dysh --cov=tests {args}"
 
 # Run tests across all supported version of Python

From ec6904f6c972fe9ae608f0e130d174d698af6b25 Mon Sep 17 00:00:00 2001
From: Thomas Chamberlin <tchamberlin@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:57:34 -0400
Subject: [PATCH 12/12] Remove requirements_dev.txt; not used

---
 requirements_dev.txt | 15 ---------------
 1 file changed, 15 deletions(-)
 delete mode 100644 requirements_dev.txt

diff --git a/requirements_dev.txt b/requirements_dev.txt
deleted file mode 100644
index 09f72642..00000000
--- a/requirements_dev.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-pip
-wheel
-watchdog
-hatch
-tox
-coverage
-Sphinx
-twine
-pytest
-pre-commit
-black
-sphinx_rtd_theme
-sphinxcontrib_mermaid
-myst_parser
-wget