Linter fixups for test code

tests/testTransforms.py

@@ -37,47 +37,53 @@
     ScaledPolynomialTransformFitter
 )
 
+
 def makeRandomCoefficientMatrix(n):
     matrix = np.random.randn(n, n)
     for i in range(1, n):
-        matrix[i, (n-i):] = 0;
+        matrix[i, (n-i):] = 0
     return matrix
 
+
 def makeRandomAffineTransform():
     return lsst.afw.geom.AffineTransform(
-        lsst.afw.geom.LinearTransform(np.random.randn(2,2)),
+        lsst.afw.geom.LinearTransform(np.random.randn(2, 2)),
         lsst.afw.geom.Extent2D(*np.random.randn(2))
     )
 
+
 def makeRandomPolynomialTransform(order, sip=False):
     xc = makeRandomCoefficientMatrix(order + 1)
     yc = makeRandomCoefficientMatrix(order + 1)
     if sip:
-        xc[0,0] = 0
-        yc[0,0] = 0
-        xc[0,1] = 0
-        yc[0,1] = 0
-        xc[1,0] = 0
-        yc[1,0] = 0
+        xc[0, 0] = 0
+        yc[0, 0] = 0
+        xc[0, 1] = 0
+        yc[0, 1] = 0
+        xc[1, 0] = 0
+        yc[1, 0] = 0
     return PolynomialTransform(xc, yc)
 
+
 def makeRandomScaledPolynomialTransform(order):
     return ScaledPolynomialTransform(
         makeRandomPolynomialTransform(order),
         makeRandomAffineTransform(),
         makeRandomAffineTransform()
     )
 
+
 def makeRandomSipForwardTransform(order):
     return SipForwardTransform(
         lsst.afw.geom.Point2D(*np.random.randn(2)),
         lsst.afw.geom.LinearTransform(np.random.randn(2,2)),
         makeRandomPolynomialTransform(order, sip=True)
     )
 
+
 def makeRandomSipReverseTransform(order):
     origin = lsst.afw.geom.Point2D(*np.random.randn(2))
-    cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+    cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
     poly = makeRandomPolynomialTransform(order, sip=False)
     return SipReverseTransform(origin, cd, poly)
 
@@ -100,7 +106,7 @@ def testLinearize(self):
         """Test that the AffineTransform returned by linearize() is equivalent
         to the transform at the expansion point, and matches finite differences.
         """
-        transform = self.makeRandom();
+        transform = self.makeRandom()
         point = lsst.afw.geom.Point2D(*np.random.randn(2))
         affine = transform.linearize(point)
         self.assertClose(np.array(transform(point)), np.array(affine(point)), rtol=1E-14)
@@ -180,7 +186,7 @@ def testCompose(self):
         """
         poly = makeRandomPolynomialTransform(4)
         affine = lsst.afw.geom.AffineTransform(
-            lsst.afw.geom.LinearTransform(np.random.randn(2,2)),
+            lsst.afw.geom.LinearTransform(np.random.randn(2, 2)),
             lsst.afw.geom.Extent2D(*np.random.randn(2))
         )
         composed1 = lsst.meas.astrom.compose(poly, affine)
@@ -246,24 +252,24 @@ def makeRandom(self):
 
     def testConstruction(self):
         poly = makeRandomPolynomialTransform(4, sip=True)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = SipForwardTransform(crpix, cd, poly)
         self.assertTransformsNearlyEqual(
             sip,
-            lambda p: cd((p - crpix) + poly(lsst.afw.geom.Point2D(p- crpix)))
+            lambda p: cd((p - crpix) + poly(lsst.afw.geom.Point2D(p - crpix)))
         )
 
     def testConvertPolynomial(self):
         poly = makeRandomPolynomialTransform(4)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = lsst.meas.astrom.SipForwardTransform.convert(poly, crpix, cd)
         self.assertTransformsNearlyEqual(sip, poly)
 
     def testConvertScaledPolynomialManual(self):
         scaled = makeRandomScaledPolynomialTransform(4)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = lsst.meas.astrom.SipForwardTransform.convert(scaled, crpix, cd)
         self.assertTransformsNearlyEqual(sip, scaled)
@@ -287,14 +293,18 @@ def testMakeWcs(self):
         )
         # We can only test agreement with TanWcs in one direction, because
         # TanWcs doesn't provide an inverse to skyToIntermediateWorldCoord.
+
         def t1(p):
             sky = lsst.afw.coord.IcrsCoord(crval + lsst.afw.geom.Extent2D(p), lsst.afw.geom.degrees)
             return rev(wcs.skyToIntermediateWorldCoord(sky))
+
         def t2(p):
             sky = lsst.afw.coord.IcrsCoord(crval + lsst.afw.geom.Extent2D(p), lsst.afw.geom.degrees)
             return wcs.skyToPixel(sky)
+
         self.assertTransformsNearlyEqual(t1, t2)
 
+
 class SipReverseTransformTestCase(lsst.utils.tests.TestCase, TransformTestMixin):
 
     def setUp(self):
@@ -305,7 +315,7 @@ def makeRandom(self):
 
     def testConstruction(self):
         poly = makeRandomPolynomialTransform(4)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = SipReverseTransform(crpix, cd, poly)
         offset = lsst.afw.geom.Extent2D(crpix)
@@ -317,14 +327,14 @@ def testConstruction(self):
 
     def testConvertPolynomial(self):
         poly = makeRandomPolynomialTransform(4)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = lsst.meas.astrom.SipReverseTransform.convert(poly, crpix, cd)
         self.assertTransformsNearlyEqual(sip, poly)
 
     def testConvertScaledPolynomialManual(self):
         scaled = makeRandomScaledPolynomialTransform(4)
-        cd = lsst.afw.geom.LinearTransform(np.random.randn(2,2))
+        cd = lsst.afw.geom.LinearTransform(np.random.randn(2, 2))
         crpix = lsst.afw.geom.Point2D(*np.random.randn(2))
         sip = lsst.meas.astrom.SipReverseTransform.convert(scaled, crpix, cd)
         self.assertTransformsNearlyEqual(sip, scaled)
@@ -349,8 +359,10 @@ def testFromMatches(self):
         cd = lsst.afw.geom.LinearTransform.makeScaling((0.2*lsst.afw.geom.arcseconds).asDegrees())
         initialWcs = lsst.afw.image.makeWcs(crval, crpix, cd[cd.XX], cd[cd.XY], cd[cd.YX], cd[cd.YY])
         bbox = lsst.afw.geom.Box2D(
-            lsst.afw.geom.Point2D(crval.getPosition(lsst.afw.geom.arcseconds)) - lsst.afw.geom.Extent2D(20, 20),
-            lsst.afw.geom.Point2D(crval.getPosition(lsst.afw.geom.arcseconds)) + lsst.afw.geom.Extent2D(20, 20)
+            (lsst.afw.geom.Point2D(crval.getPosition(lsst.afw.geom.arcseconds))
+                - lsst.afw.geom.Extent2D(20, 20)),
+            (lsst.afw.geom.Point2D(crval.getPosition(lsst.afw.geom.arcseconds))
+                + lsst.afw.geom.Extent2D(20, 20))
         )
         srcSchema = lsst.afw.table.SourceTable.makeMinimalSchema()
         srcPosKey = lsst.afw.table.Point2DKey.addFields(srcSchema, "pos", "source position", "pix")
@@ -382,8 +394,9 @@ def testFromMatches(self):
             covSqrt = np.random.randn(3, 2)
             cov = (errScaling*(np.dot(covSqrt.transpose(), covSqrt)
                    + np.diag([1.0, 1.0]))).astype(np.float32)
-            # We don't actually perturb positions according to noise level, as this makes it much harder to test
-            # that the result agrees with what we put in.
+            # We don't actually perturb positions according to noise level, as
+            # this makes it much harder to test that the result agrees with
+            # what we put in.
             measPos = truePos
             measRec.set(srcPosKey, measPos)
             measRec.set(srcErrKey, cov)
@@ -417,7 +430,7 @@ def testFromMatches(self):
             scaledOutBBox.include(scaledOut)
             self.assertClose(np.array(expected(scaledIn)), np.array(scaledOut), rtol=1E-7)
             j = 0
-            for n in range(order +1):
+            for n in range(order + 1):
                 for p in range(n + 1):
                     q = n - p
                     vandermonde[i, j] = scaledIn.getX()**p * scaledIn.getY()**q
@@ -443,7 +456,6 @@ def testFromMatches(self):
         self.assertClose(fittedPoly.getXCoeffs(), truePoly.getXCoeffs(), rtol=1E-7, atol=1E-7)
         self.assertClose(fittedPoly.getYCoeffs(), truePoly.getYCoeffs(), rtol=1E-7, atol=1E-7)
 
-
     def testFromGrid(self):
         outOrder = 8
         inOrder = 2
@@ -456,7 +468,6 @@ def testFromGrid(self):
         result = fitter.getTransform()
         inputKey = lsst.afw.table.Point2DKey(data.schema["input"])
         outputKey = lsst.afw.table.Point2DKey(data.schema["output"])
-        modelKey = lsst.afw.table.Point2DKey(data.schema["model"])
         for record in data:
             self.assertClose(np.array(record.get(inputKey)), np.array(toInvert(record.get(outputKey))))
             self.assertClose(
@@ -469,9 +480,10 @@ def testFromGrid(self):
 class MemoryTester(lsst.utils.tests.MemoryTestCase):
     pass
 
+
 def setup_module(module):
     lsst.utils.tests.init()
 
 if __name__ == "__main__":
     lsst.utils.tests.init()
-    unittest.main()
+    unittest.main()