def testGetPropertyListFromFitsChanUnsupportedTypes(self):
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
fc.setFitsCF("ACOMPLEX", complex(1, 1))
with self.assertRaises(lsst.pex.exceptions.TypeError):
getPropertyListFromFitsChan(fc)
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
fc.setFitsU("UNDEFVAL")
with self.assertRaises(lsst.pex.exceptions.TypeError):
getPropertyListFromFitsChan(fc)
def test_FitsChanFindFits(self):
ss = astshim.StringStream("".join(self.cards))
fc = astshim.FitsChan(ss)
fc.setCard(9)
fv = fc.findFits("%f", False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL1 = 0"))
fc.delFits()
self.assertEqual(fc.nCard, len(self.cards) - 1)
self.assertEqual(fc.getCard(), 9)
fv = fc.findFits("%f", False)
self.assertEqual(fc.getCard(), 9)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL2 = 0"))
fc.putFits("CRVAL1 = 0", False)
self.assertEqual(fc.nCard, len(self.cards))
self.assertEqual(fc.getCard(), 10)
fv = fc.findFits("%f", False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL2 = 0"))
fv = fc.findFits("CTYPE2", False)
self.assertFalse(fv.found)
fc.clearCard()
fv = fc.findFits("CTYPE2", False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CTYPE2 = 'DEC-TAN '"))
self.assertEqual(fc.getCard(), 4)
def testGetFitsCardsNoComments(self):
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
# add one card for each supported type, with a comment
continueVal = "This is a continue card"
floatVal = 1.5
intVal = 99
logicalVal = True
stringVal = "This is a string"
fc.setFitsCN("ACONT", continueVal)
fc.setFitsF("AFLOAT", floatVal)
fc.setFitsI("ANINT", intVal)
fc.setFitsL("ALOGICAL", logicalVal)
fc.setFitsS("ASTRING", stringVal)
fc.setFitsCM("a comment, which will be ignored by getPropertyListFromFitsChan")
self.assertEqual(fc.nCard, 6)
metadata = getPropertyListFromFitsChan(fc)
self.assertEqual(metadata.getOrderedNames(), ["ACONT", "AFLOAT", "ANINT", "ALOGICAL", "ASTRING"])
self.assertEqual(metadata.get("ACONT"), continueVal)
self.assertAlmostEqual(metadata.get("AFLOAT"), floatVal)
self.assertEqual(metadata.get("ANINT"), intVal)
self.assertEqual(metadata.get("ALOGICAL"), logicalVal)
self.assertEqual(metadata.get("ASTRING"), stringVal)
self.assertEqual(metadata.get("ACONT"), continueVal)
def test_FitsChanGetFits(self):
fc = astshim.FitsChan(astshim.StringStream())
self.assertEqual(fc.className, "FitsChan")
fc.setFitsI("FRED", 99, "Hello there", True)
fv = fc.getFitsI("FRED")
self.assertTrue(fv.found)
self.assertEqual(fv.value, 99)
fv = fc.getFitsS("FRED")
self.assertTrue(fv.found)
self.assertEqual(fv.value, "99")
self.assertEqual(fc.nCard, 1)
self.assertEqual(fc.getAllCardNames(), ["FRED"])
# replace this card
fc.setFitsF("FRED1", 99.9, "Hello there", True)
fv = fc.getFitsS("FRED1")
self.assertTrue(fv.found)
self.assertEqual(fv.value, "99.9")
self.assertEqual(fc.nCard, 1)
self.assertEqual(fc.getAllCardNames(), ["FRED1"])
fc.setFitsCF("FRED1", complex(99.9, 99.8), "Hello there", True)
fv = fc.getFitsCF("FRED1")
self.assertTrue(fv.found)
self.assertEqual(fv.value.real, 99.9)
self.assertEqual(fv.value.imag, 99.8)
fc.setFitsS("FRED1", "-12", "Hello there", True)
fv = fc.getFitsI("FRED1")
self.assertTrue(fv.found)
self.assertEqual(fv.value, -12)
self.assertEqual(fc.nCard, 1)
self.assertEqual(fc.getAllCardNames(), ["FRED1"])
def test_FitsChanInsertShift(self):
"""Check that a simple WCS can still be written as FITS-WCS
after inserting a shift at the beginning of GRID to IWC
This tests LSST ticket DM-12524
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss, "Encoding=FITS-WCS, IWC=1")
frameSet = fc.read()
self.assertIsInstance(frameSet, ast.FrameSet)
self.assertAlmostEqual(fc.fitsTol, 0.1)
shift = 30
shiftMap = ast.ShiftMap([shift, shift])
shiftedFrameSet = self.insertPixelMapping(shiftMap, frameSet)
fc2 = writeFitsWcs(frameSet)
self.assertGreater(fc2.nCard, 9)
for i in (1, 2):
fv = fc2.getFitsF("CRPIX%d" % (i,))
self.assertAlmostEqual(fv.value, 100)
fc3 = writeFitsWcs(shiftedFrameSet)
self.assertGreaterEqual(fc3.nCard, fc2.nCard)
for i in (1, 2):
fv = fc3.getFitsF("CRPIX%d" % (i,))
self.assertAlmostEqual(fv.value, 100 - shift)
for name in fc2.getAllCardNames():
self.assertEqual(fc3.testFits(name), ast.FitsKeyState.PRESENT)
def test_FitsChanFitsTol(self):
"""Test that increasing FitsTol allows writing a WCS with distortion
as FITS-WCS.
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss, "Encoding=FITS-WCS, IWC=1")
frameSet = fc.read()
distortion = ast.PcdMap(0.001, [0.0, 0.0])
distortedFrameSet = self.insertPixelMapping(distortion, frameSet)
# Writing as FTIS-WCS should fail with the default FitsTol
fc = writeFitsWcs(distortedFrameSet)
self.assertEqual(fc.nCard, 0)
# Writing as FITS-WCS should succeed with adequate FitsTol
fc2 = writeFitsWcs(distortedFrameSet, "FitsTol=1000")
self.assertGreater(fc2.nCard, 9)
for i in (1, 2):
fv = fc2.getFitsF("CRVAL%d" % (i,))
self.assertAlmostEqual(fv.value, 0)
fv2 = fc2.getFitsS("CTYPE1")
self.assertEqual(fv2.value, "RA---TAN")
fv3 = fc2.getFitsS("CTYPE2")
self.assertEqual(fv3.value, "DEC--TAN")
def readObjectFromShow(path):
"""Read an ast object saved as Object.show()"""
with open(path, "r") as f:
objectText = f.read()
stream = ast.StringStream(objectText)
chan = ast.Channel(stream)
return chan.read()
def test_XmlChanSpecifiedAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(
sstream, 'XmlFormat="QUOTED", XmlLength=2000, XmlPrefix="foo"')
self.assertEqual(chan.xmlFormat, "QUOTED")
self.assertEqual(chan.xmlLength, 2000)
self.assertEqual(chan.xmlPrefix, "foo")
zoommap = ast.ZoomMap(4, 1.5)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def test_XmlChanDefaultAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(sstream)
self.assertEqual(chan.xmlFormat, "NATIVE")
self.assertEqual(chan.xmlLength, 0)
self.assertEqual(chan.xmlPrefix, "")
zoommap = ast.ZoomMap(3, 2.0)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def test_FitsChanWriteOnDelete(self):
"""Test that a FitsChan writes cards when it is deleted
"""
ss = ast.StringStream()
fc = ast.FitsChan(ss)
fc.putCards("".join(self.cards))
self.assertEqual(ss.getSinkData(), "")
del fc
self.assertEqual(len(ss.getSinkData()), 80 * len(self.cards))
def testGetPropertyListFromFitsChanWithComments(self):
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
# add one card for each supported type, with a comment
continueVal = "This is a continue card"
floatVal = 1.5
intVal = 99
logicalVal = True
stringVal = "This is a string"
fc.setFitsCN("ACONT", continueVal, "Comment for ACONT")
fc.setFitsF("AFLOAT", floatVal, "Comment for AFLOAT")
fc.setFitsI("ANINT", intVal, "Comment for ANINT")
fc.setFitsL("ALOGICAL", logicalVal, "Comment for ALOGICAL")
fc.setFitsS("ASTRING", stringVal, "Comment for ASTRING")
fc.setFitsCM("a comment, which will be ignored by getPropertyListFromFitsChan")
expectedNames = ["ACONT", "AFLOAT", "ANINT", "ALOGICAL", "ASTRING"]
self.assertEqual(fc.nCard, 6)
metadata = getPropertyListFromFitsChan(fc)
self.assertEqual(metadata.getOrderedNames(), expectedNames)
self.assertEqual(metadata.get("ACONT"), continueVal)
self.assertAlmostEqual(metadata.get("AFLOAT"), floatVal)
self.assertEqual(metadata.get("ANINT"), intVal)
self.assertEqual(metadata.get("ALOGICAL"), logicalVal)
self.assertEqual(metadata.get("ASTRING"), stringVal)
self.assertEqual(metadata.get("ACONT"), continueVal)
for name in expectedNames:
self.assertEqual(metadata.getComment(name), "Comment for %s" % (name,))
# complex values are not supported by PropertyList
fc.setFitsCF("UNSUPP", complex(1, 0))
badCard = fc.getCard()
with self.assertRaises(lsst.pex.exceptions.TypeError):
getPropertyListFromFitsChan(fc)
fc.setCard(badCard)
fc.clearCard()
fc.findFits("UNSUPP", inc=False)
fc.delFits()
metadata = getPropertyListFromFitsChan(fc)
self.assertEqual(metadata.getOrderedNames(), expectedNames)
# cards with no value are not supported by PropertyList
fc.setFitsU("UNSUPP")
badCard = fc.getCard()
with self.assertRaises(lsst.pex.exceptions.TypeError):
getPropertyListFromFitsChan(fc)
fc.setCard(badCard)
fc.clearCard()
fc.findFits("UNSUPP", inc=False)
fc.delFits()
metadata = getPropertyListFromFitsChan(fc)
self.assertEqual(metadata.getOrderedNames(), expectedNames)
def writeFitsWcs(frameSet, extraOptions=None):
"""Write a FrameSet as FITS-WCS
extraOptions are in addition to Encoding=Fits-WCS, CDMatrix=1
"""
options = "Encoding=FITS-WCS, CDMatrix=1"
if extraOptions is not None:
options = "%s, %s" % (options, extraOptions)
fc = ast.FitsChan(ast.StringStream(), options)
fc.write(frameSet)
return fc
def test_XmlChanSetAttributes(self):
sstream = ast.StringStream()
chan = ast.XmlChan(sstream)
chan.xmlFormat = "QUOTED"
chan.xmlLength = 1500
chan.xmlPrefix = "test"
self.assertEqual(chan.xmlFormat, "QUOTED")
self.assertEqual(chan.xmlLength, 1500)
self.assertEqual(chan.xmlPrefix, "test")
zoommap = ast.ZoomMap(1, 0.5)
self.checkXmlPersistence(sstream=sstream, chan=chan, obj=zoommap)
def test_FitsChanPreloaded(self):
"""Test a FitsChan that starts out loaded with data
"""
ss = astshim.StringStream("".join(self.cards))
fc = astshim.FitsChan(ss)
self.assertEqual(fc.nCard, len(self.cards))
# there are 2 COMMENT and 3 HISTORY cards, so 3 fewer unique keys
self.assertEqual(fc.nKey, len(self.cards) - 3)
self.assertEqual(fc.className, "FitsChan")
fv = fc.getFitsF("CRVAL1")
self.assertTrue(fv.found)
self.assertEqual(fv.value, 0.0)
self.assertEqual(fc.encoding, "FITS-WCS")
def test_ChannelStringStream(self):
ss = ast.StringStream()
channel = ast.Channel(ss)
zoommap = ast.ZoomMap(2, 0.1, "ID=Hello there")
n = channel.write(zoommap)
self.assertEqual(n, 1)
sinkData1 = ss.getSinkData()
ss.sinkToSource()
obj = channel.read()
self.assertEqual(obj.show(), zoommap.show())
n = channel.write(obj)
self.assertEqual(n, 1)
sinkData2 = ss.getSinkData()
self.assertEqual(sinkData1, sinkData2)
def test_FitsChanAttributes(self):
"""Test getting and setting FitsChan attributes
Does not test the behavior of the attributes.
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss)
self.assertFalse(fc.carLin)
self.assertFalse(fc.cdMatrix)
self.assertFalse(fc.clean)
self.assertFalse(fc.defB1950)
self.assertEqual(fc.encoding, "FITS-WCS")
self.assertEqual(fc.fitsAxisOrder, "<auto>")
self.assertAlmostEqual(fc.fitsTol, 0.1)
self.assertFalse(fc.iwc)
self.assertTrue(fc.sipOK)
self.assertTrue(fc.sipReplace)
self.assertEqual(fc.tabOK, 0)
self.assertEqual(fc.polyTan, -1)
warningSet = set(fc.warnings.split(" "))
desiredWarningSet = set(
"BadKeyName BadKeyValue Tnx Zpx BadCel BadMat BadPV BadCTYPE".
split(" "))
self.assertEqual(warningSet, desiredWarningSet)
fc.carLin = True
self.assertTrue(fc.carLin)
fc.cdMatrix = True
self.assertTrue(fc.cdMatrix)
fc.clean = True
self.assertTrue(fc.clean)
fc.defB1950 = True
self.assertTrue(fc.defB1950)
fc.encoding = "NATIVE"
self.assertEqual(fc.encoding, "NATIVE")
fc.fitsAxisOrder = "<copy>"
self.assertEqual(fc.fitsAxisOrder, "<copy>")
fc.fitsTol = 0.001
self.assertAlmostEqual(fc.fitsTol, 0.001)
fc.iwc = True
self.assertTrue(fc.iwc)
fc.tabOK = 1
self.assertEqual(fc.tabOK, 1)
fc.polyTan = 0
self.assertEqual(fc.polyTan, 0)
fc.warnings = "BadKeyName BadMat"
self.assertEqual(fc.warnings, "BadKeyName BadMat")
def test_FitsChanDM13686(self):
"""Test that a particular FrameSet will not segfault when
we attempt to write it to a FitsChan as FITS-WCS
"""
def readObjectFromShow(path):
"""Read an ast object saved as Object.show()"""
with open(path, "r") as f:
objectText = f.read()
stream = ast.StringStream(objectText)
chan = ast.Channel(stream)
return chan.read()
path = os.path.join(self.dataDir, "frameSetDM13686.txt")
frameSet = readObjectFromShow(path)
strStream = ast.StringStream()
fitsChan = ast.FitsChan(strStream, "Encoding=FITS-WCS")
# This FrameSet can be represtented as FITS-WCS, so 1 object is written
self.assertEqual(fitsChan.write(frameSet), 1)
def test_FitsChanPreloaded(self):
"""Test a FitsChan that starts out loaded with data
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss)
self.assertEqual(fc.nCard, len(self.cards))
# there are 2 COMMENT and 3 HISTORY cards,
# and two BOOL cards so 4 fewer unique keys
self.assertEqual(fc.nKey, len(self.cards) - 4)
self.assertEqual(fc.className, "FitsChan")
fv = fc.getFitsF("CRVAL1")
self.assertTrue(fv.found)
self.assertEqual(fv.value, 0.0)
self.assertEqual(fc.encoding, "FITS-WCS")
self.assertEqual(fc.getAllCardNames(),
[card.split(" ", 1)[0] for card in self.cards])
def test_FitsChanTestFits(self):
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
# add a card for each type
fc.setFitsF("AFLOAT", 1.5)
fc.setFitsS("ASTRING", "a string")
fc.setFitsU("UNDEFVAL")
self.assertEqual(fc.testFits("AFLOAT"), ast.FitsKeyState.PRESENT)
self.assertEqual(fc.testFits("ASTRING"), ast.FitsKeyState.PRESENT)
self.assertEqual(fc.testFits("UNDEFVAL"), ast.FitsKeyState.NOVALUE)
self.assertEqual(fc.testFits("BADNAME"), ast.FitsKeyState.ABSENT)
fc.setCard(1)
self.assertEqual(fc.getCardName(), "AFLOAT")
self.assertEqual(fc.testFits(), ast.FitsKeyState.PRESENT)
fc.setCard(3)
self.assertEqual(fc.getCardName(), "UNDEFVAL")
self.assertEqual(fc.testFits(), ast.FitsKeyState.NOVALUE)
def test_FitsChanPutCardsPutFits(self):
ss = ast.StringStream()
fc = ast.FitsChan(ss)
cards = "CRVAL1 = 0 " + \
"CRVAL2 = 0 "
fc.putCards(cards)
self.assertEqual(fc.getCard(), 1)
fc.setCard(100) # past the end = end of cards
self.assertEqual(fc.getCard(), 3)
fc.clearCard()
self.assertEqual(fc.getCard(), 1)
self.assertEqual(fc.getAllCardNames(), ["CRVAL1", "CRVAL2"])
# insert new cards at the beginning
for card in self.cards[0:8]:
fc.putFits(card, overwrite=False)
self.assertEqual(fc.nCard, 10)
self.assertEqual(fc.getCard(), 9)
predCardNames = [c.split()[0] for c in self.cards[0:8]] + ["CRVAL1", "CRVAL2"]
self.assertEqual(fc.getAllCardNames(), predCardNames)
def test_FitsChanGetCurrentForNonexistentCard(self):
"""Test getting info on the current card when it does not exist
"""
fc = ast.FitsChan(ast.StringStream())
fc.setFitsI("ANINT", 200)
fc.setFitsS("ASTRING", "string value")
fc.setCard(fc.nCard + 1)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.testFits(), ast.FitsKeyState.ABSENT)
with self.assertRaises(RuntimeError):
fc.getFitsCN()
with self.assertRaises(RuntimeError):
fc.getFitsF()
with self.assertRaises(RuntimeError):
fc.getFitsI()
with self.assertRaises(RuntimeError):
fc.getFitsL()
with self.assertRaises(RuntimeError):
fc.getFitsS()
with self.assertRaises(RuntimeError):
fc.getFitsCF()
self.assertEqual(fc.getCardName(), "")
self.assertEqual(fc.getCardComm(), "")
def test_FitsChanEmptyFits(self):
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss)
self.assertEqual(fc.nCard, len(self.cards))
fc.emptyFits()
self.assertEqual(fc.nCard, 0)
def test_FitsChanGetFitsSetFits(self):
"""Test FitsChan.getFits<X>, FitsChan.setFits<X> and getCardType
"""
fc = ast.FitsChan(ast.StringStream())
self.assertEqual(fc.className, "FitsChan")
# add a card for each type
complexVal = complex(9.8, -5.15)
continueVal = "This is a continue card"
floatVal = 1.5
intVal = 99
logicalVal = True
strVal = "This is a string"
fc.setFitsCF("ACOMPLEX", complexVal, "Comment for ACOMPLEX")
commentVal = "This is a comment"
fc.setFitsCN("ACONT", continueVal, "Comment for ACONT")
fc.setFitsF("AFLOAT", floatVal, "Comment for AFLOAT")
fc.setFitsI("ANINT", intVal, "Comment for ANINT")
fc.setFitsL("ALOGICAL", logicalVal, "Comment for ALOGICAL")
fc.setFitsS("ASTRING", strVal, "Comment for ASTRING")
fc.setFitsU("UNDEFVAL", "Comment for UNDEFVAL")
fc.setFitsCM(commentVal)
self.assertEqual(fc.nCard, 8)
self.assertEqual(fc.getAllCardNames(),
["ACOMPLEX", "ACONT", "AFLOAT", "ANINT",
"ALOGICAL", "ASTRING", "UNDEFVAL", " "])
fv = fc.getFitsI("ANINT")
self.assertEqual(fc.getCardType(), ast.CardType.INT)
self.assertTrue(fv.found)
self.assertEqual(fv.value, intVal)
self.assertEqual(fc.getCardComm(), "Comment for ANINT")
self.assertEqual(fc.getCard(), 4)
fv = fc.getFitsS("ANINT")
self.assertTrue(fv.found)
self.assertEqual(fv.value, str(intVal))
self.assertEqual(fc.getCard(), 4)
fv = fc.getFitsI() # read the current card
self.assertTrue(fv.found)
self.assertEqual(fv.value, intVal)
self.assertEqual(fc.getCard(), 4)
fv = fc.getFitsI("") # alternate way to read the current card
self.assertTrue(fv.found)
self.assertEqual(fv.value, intVal)
self.assertEqual(fc.getCard(), 4)
fv = fc.getFitsF("AFLOAT")
self.assertEqual(fc.getCardType(), ast.CardType.FLOAT)
self.assertEqual(fc.getCard(), 3)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, floatVal)
self.assertEqual(fc.getCardComm(), "Comment for AFLOAT")
fv = fc.getFitsF() # read the current card
self.assertEqual(fc.getCardType(), ast.CardType.FLOAT)
self.assertEqual(fc.getCard(), 3)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, floatVal)
self.assertEqual(fc.getCardComm(), "Comment for AFLOAT")
fv = fc.getFitsCN("ACONT")
self.assertEqual(fc.getCardType(), ast.CardType.CONTINUE)
self.assertEqual(fc.getCard(), 2)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, continueVal)
self.assertEqual(fc.getCardComm(), "Comment for ACONT")
fv = fc.getFitsCN() # read the current card
self.assertEqual(fc.getCardType(), ast.CardType.CONTINUE)
self.assertEqual(fc.getCard(), 2)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, continueVal)
self.assertEqual(fc.getCardComm(), "Comment for ACONT")
fv = fc.getFitsCF("ACOMPLEX")
self.assertEqual(fc.getCardType(), ast.CardType.COMPLEXF)
self.assertEqual(fc.getCard(), 1)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, complexVal)
self.assertEqual(fc.getCardComm(), "Comment for ACOMPLEX")
fv = fc.getFitsCF() # read the current card
self.assertEqual(fc.getCardType(), ast.CardType.COMPLEXF)
self.assertEqual(fc.getCard(), 1)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, complexVal)
self.assertEqual(fc.getCardComm(), "Comment for ACOMPLEX")
fv = fc.getFitsL("ALOGICAL")
self.assertEqual(fc.getCardType(), ast.CardType.LOGICAL)
self.assertEqual(fc.getCard(), 5)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, logicalVal)
self.assertEqual(fc.getCardComm(), "Comment for ALOGICAL")
fv = fc.getFitsL() # read the current card
self.assertEqual(fc.getCardType(), ast.CardType.LOGICAL)
self.assertEqual(fc.getCard(), 5)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, logicalVal)
self.assertEqual(fc.getCardComm(), "Comment for ALOGICAL")
fv = fc.getFitsS("ASTRING")
self.assertEqual(fc.getCardType(), ast.CardType.STRING)
self.assertEqual(fc.getCard(), 6)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, strVal)
self.assertEqual(fc.getCardComm(), "Comment for ASTRING")
fv = fc.getFitsS() # read the current card
self.assertEqual(fc.getCardType(), ast.CardType.STRING)
self.assertEqual(fc.getCard(), 6)
self.assertTrue(fv.found)
self.assertAlmostEqual(fv.value, strVal)
self.assertEqual(fc.getCardComm(), "Comment for ASTRING")
fv = fc.getFitsS("BADNAME") # a card that does not exist
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
self.assertFalse(fv.found)
fc.setCard(7)
self.assertEqual(fc.getCardType(), ast.CardType.UNDEF)
with self.assertRaises(RuntimeError):
fc.getFitsS()
self.assertEqual(fc.getCardComm(), "Comment for UNDEFVAL")
fc.setCard(8)
self.assertEqual(fc.getCardType(), ast.CardType.COMMENT)
with self.assertRaises(RuntimeError):
fc.getFitsS()
self.assertEqual(fc.getCardComm(), commentVal)
# replace ANINT card with new everything: name, value type and comment
fc.setCard(4)
fc.setFitsCF("NEWNAME", complex(99.9, 99.8), "New comment", overwrite=True)
self.assertEqual(fc.getAllCardNames(),
["ACOMPLEX", "ACONT", "AFLOAT", "NEWNAME",
"ALOGICAL", "ASTRING", "UNDEFVAL", " "])
fc.setCard(1) # force a search
fv = fc.getFitsCF("NEWNAME")
self.assertTrue(fv.found)
self.assertEqual(fv.value.real, 99.9)
self.assertEqual(fv.value.imag, 99.8)
self.assertEqual(fc.getCardComm(), "New comment")
self.assertEqual(fc.getCard(), 4)
def test_FitsChanGetFitsMissing(self):
"""Test FitsChan.getFits<X> for missing cards, with and without
defaults
"""
fc = ast.FitsChan(ast.StringStream())
fc.setFitsI("ANINT", 200)
fc.setFitsS("ASTRING", "string value")
self.assertEqual(fc.nCard, 2)
# test getFitsX for missing cards with default values
fv = fc.getFitsCF("BOGUS", complex(9, -5))
self.assertFalse(fv.found)
self.assertEqual(fv.value, complex(9, -5))
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsCN("BOGUS", "not_there")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "not_there")
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsF("BOGUS", 55.5)
self.assertFalse(fv.found)
self.assertEqual(fv.value, 55.5)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsI("BOGUS", 55)
self.assertFalse(fv.found)
self.assertEqual(fv.value, 55)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsL("BOGUS", True)
self.assertFalse(fv.found)
self.assertEqual(fv.value, True)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsS("BOGUS", "missing")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "missing")
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
# test getFitsX for missing cards without default values
fv = fc.getFitsCF("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, complex())
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsCN("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsF("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, 0)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsI("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, 0)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsL("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, False)
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.getFitsS("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
self.assertEqual(fc.getCardType(), ast.CardType.NOTYPE)
self.assertEqual(fc.getCard(), fc.nCard + 1)
fv = fc.findFits("BOGUS", inc=False)
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
def test_python(self):
"""Test Python Mapping/Sequence interface to FitsChan.
"""
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss)
self.assertEqual(len(fc), 18)
cards = "".join(c for c in fc)
self.assertEqual(cards, "".join(self.cards))
self.assertIn("CTYPE2", fc)
self.assertIn(10, fc)
self.assertNotIn(-1, fc)
self.assertNotIn(20, fc)
self.assertNotIn("CTYPE3", fc)
self.assertEqual(fc["CTYPE1"], "RA--TAN")
self.assertEqual(fc["NAXIS2"], 200)
self.assertEqual(fc["CDELT2"], 0.001)
self.assertFalse(fc["BOOL"])
self.assertEqual(fc[4].rstrip(), "CRPIX1 = 100")
with self.assertRaises(KeyError):
fc["NOTIN"]
with self.assertRaises(IndexError):
fc[100]
# Update values
fc["BOOL"] = True # This will remove second card
self.assertEqual(fc["BOOL"], True)
fc["CRVAL2"] = None
self.assertIsNone(fc["CRVAL2"])
fc["NEWSTR"] = "Test"
self.assertEqual(fc["NEWSTR"], "Test")
fc["NEWINT"] = 1024
self.assertEqual(fc["NEWINT"], 1024)
fc["NEWFLT"] = 3.5
self.assertEqual(fc["NEWFLT"], 3.5)
fc["UNDEF"] = "not undef"
self.assertEqual(fc["UNDEF"], "not undef")
fc[""] = "A new BLANK comment"
fc[0] = "COMMENT Introduction comment"
self.assertEqual(fc[0].rstrip(), "COMMENT Introduction comment")
# This will fail since a string is required
with self.assertRaises(TypeError):
fc[0] = 52
# Delete the 3rd card
del fc[2]
self.assertEqual(fc[2].rstrip(), "CTYPE2 = 'DEC-TAN '")
self.assertEqual(len(fc), 20)
# Delete all the HISTORY cards
del fc["HISTORY"]
self.assertEqual(len(fc), 17)
# Change a card to blank
fc[3] = None
self.assertEqual(fc[3].strip(), "")
fc[3] = "COMMENT 1"
self.assertEqual(fc[3].strip(), "COMMENT 1")
fc[3] = ""
self.assertEqual(fc[3].strip(), "")
# Use negative index
self.assertEqual(fc[-1], fc[fc.nCard-1])
fc[-2] = "COMMENT new comment"
self.assertEqual(fc[-2], fc[fc.nCard-2])
self.assertEqual(fc[-2].rstrip(), "COMMENT new comment")
# Append a comment to the end
nCards = len(fc)
fc[fc.nCard] = "COMMENT X"
self.assertEqual(len(fc), nCards + 1)
self.assertEqual(fc[-1].rstrip(), "COMMENT X")
# Try to access and append using a high index
with self.assertRaises(IndexError):
fc[fc.nCard + 1]
with self.assertRaises(IndexError):
fc[fc.nCard + 1] = ""
with self.assertRaises(IndexError):
fc[fc.nCard]
# Or the wrong type of key
with self.assertRaises(KeyError):
fc[3.14] = 52
# Delete final card
nCards = len(fc)
del fc[-1]
self.assertEqual(fc[-1].rstrip(), "NEWFLT = 3.5")
self.assertEqual(len(fc), nCards - 1)
with self.assertRaises(IndexError):
del fc[-fc.nCard - 1]
with self.assertRaises(IndexError):
del fc[fc.nCard]
with self.assertRaises(KeyError):
del fc[3.14]
with self.assertRaises(KeyError):
del fc["NOTTHERE"]
# Test stringification
header = str(fc)
self.assertIn("BOOL = 1", header)
# All the items
collected = []
for k, v in fc.items():
collected.append((k, v))
self.assertEqual(len(collected), len(fc))
def test_FitsChanGetFitsSetFits(self):
fc = astshim.FitsChan(astshim.StringStream())
fc.setFitsI("NAXIS1", 200)
fc.setFitsI("NAXIS2", 200)
fc.setFitsS("CTYPE1", "RA--TAN")
fc.setFitsS("CTYPE2", "DEC-TAN")
fc.setFitsI("CRPIX1", 100)
fc.setFitsI("CRPIX2", 100)
fc.setFitsF("CDELT1", 0.001)
fc.setFitsF("CDELT2", 0.001)
fc.setFitsI("CRVAL1", 0)
fc.setFitsI("CRVAL2", 0)
fc.setFitsCF("ACPLX", complex(-5.5, 4.3))
fc.setFitsL("ABOOL", False)
fc.setFitsCN("ACN", "continue_value")
fc.setFitsU("ANUNK")
self.assertEqual(fc.nCard, 14)
fv = fc.getFitsI("NAXIS1", 0)
self.assertTrue(fv.found)
self.assertEqual(fv.value, 200)
fv = fc.getFitsS("CTYPE1", "")
self.assertTrue(fv.found)
self.assertEqual(fv.value, "RA--TAN")
fv = fc.getFitsF("CDELT2", -53.2)
self.assertTrue(fv.found)
self.assertEqual(fv.value, 0.001)
fv = fc.getFitsCF("ACPLX")
self.assertTrue(fv.found)
self.assertEqual(fv.value, complex(-5.5, 4.3))
fv = fc.getFitsCN("ACN")
self.assertTrue(fv.found)
self.assertEqual(fv.value, "continue_value")
# test getFitsX for missing cards with default values
fv = fc.getFitsCF("BOGUS", complex(9, -5))
self.assertFalse(fv.found)
self.assertEqual(fv.value, complex(9, -5))
fv = fc.getFitsCN("BOGUS", "not_there")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "not_there")
fv = fc.getFitsF("BOGUS", 55.5)
self.assertFalse(fv.found)
self.assertEqual(fv.value, 55.5)
fv = fc.getFitsI("BOGUS", 55)
self.assertFalse(fv.found)
self.assertEqual(fv.value, 55)
fv = fc.getFitsL("BOGUS", True)
self.assertFalse(fv.found)
self.assertEqual(fv.value, True)
fv = fc.getFitsS("BOGUS", "missing")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "missing")
# test getFitsX for missing cards without default values
fv = fc.getFitsCF("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, complex())
fv = fc.getFitsCN("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
fv = fc.getFitsF("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, 0)
fv = fc.getFitsI("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, 0)
fv = fc.getFitsL("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, False)
fv = fc.getFitsS("BOGUS")
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
# the only way to find a card with unknown value is with findFits
fc.clearCard()
fv = fc.findFits("ANUNK", False)
self.assertTrue(fv.found)
self.assertEqual(
fv.value,
'ANUNK = '
)
fv = fc.findFits("BOGUS", False)
self.assertFalse(fv.found)
self.assertEqual(fv.value, "")
def test_FitsChanFindFits(self):
ss = ast.StringStream("".join(self.cards))
fc = ast.FitsChan(ss)
expectedNCards = fc.nCard
# append a card with no value
fc.setCard(fc.nCard + 1)
fc.setFitsU("UNDEFVAL")
expectedNCards += 1
self.assertEqual(fc.nCard, expectedNCards)
fc.setCard(9) # index of CRVAL1
self.assertEqual(fc.getCardName(), "CRVAL1")
fv = fc.findFits("%f", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL1 = 0"))
# delete CRVAL1 card
fc.delFits()
expectedNCards -= 1
self.assertEqual(fc.nCard, expectedNCards)
self.assertEqual(fc.getCard(), 9)
fv = fc.findFits("%f", inc=False)
self.assertEqual(fc.getCard(), 9)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL2 = 0"))
# insert CRVAL1 card before current card; verify that the index
# is incremented to point to the next card
fc.putFits("CRVAL1 = 99", overwrite=False)
expectedNCards += 1
self.assertEqual(fc.nCard, expectedNCards)
self.assertEqual(fc.getCard(), 10)
fv = fc.findFits("%f", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL2 = 0"))
fc.setCard(9) # index of CRVAL1
fv = fc.findFits("%f", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL1 = 99"))
# overwrite CRVAL1 card
fc.setCard(9)
fc.putFits("CRVAL1 = 0", overwrite=True)
self.assertEqual(fc.nCard, expectedNCards)
fc.setCard(9)
fv = fc.findFits("%f", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL1 = 0"))
# test that findFits does not wrap around
fv = fc.findFits("CTYPE2", inc=False)
self.assertFalse(fv.found)
fc.clearCard()
fv = fc.findFits("CTYPE2", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CTYPE2 = 'DEC-TAN '"))
self.assertEqual(fc.getCard(), 4)
# test that we can find a card with undefined value
fc.clearCard()
fv = fc.findFits("UNDEFVAL", inc=False)
self.assertTrue(fv.found)
self.assertEqual(fv.value,
"UNDEFVAL= ")
def test_FitsChanReadWrite(self):
ss = ast.StringStream("".join(self.cards))
fc1 = ast.FitsChan(ss)
obj1 = fc1.read()
self.assertEqual(obj1.className, "FrameSet")
ss2 = ast.StringStream()
fc2 = ast.FitsChan(ss2, "Encoding=FITS-WCS")
n = fc2.write(obj1)
self.assertEqual(n, 1)
self.assertEqual(fc2.nCard, 10)
fc2.clearCard()
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("WCSAXES = 2 / Number of WCS axes"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRPIX1 = 100.0 / Reference pixel on axis 1"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRPIX2 = 100.0 / Reference pixel on axis 2"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL1 = 0.0 / Value at ref. pixel on axis 1"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CRVAL2 = 0.0 / Value at ref. pixel on axis 2"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CTYPE1 = 'RA---TAN' / Type of co-ordinate on axis 1"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CTYPE2 = 'DEC--TAN' / Type of co-ordinate on axis 2"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CDELT1 = 0.001 / Pixel size on axis 1"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("CDELT2 = 0.001 / Pixel size on axis 2"))
fv = fc2.findFits("%f", inc=True)
self.assertTrue(fv.found)
self.assertEqual(fv.value, pad("RADESYS = 'ICRS ' / Reference frame for RA/DEC values"))
self.assertEqual(ss2.getSinkData(), "")
self.assertEqual(fc2.nCard, 10)
fc2.writeFits()
self.assertEqual(fc2.nCard, 0)
a = ss2.getSinkData()
ss3 = ast.StringStream(ss2.getSinkData())
fc3 = ast.FitsChan(ss3, "Encoding=FITS-WCS")
fc3.readFits()
obj3 = fc3.read()
ss4 = ast.StringStream()
fc4 = ast.FitsChan(ss4, "Encoding=FITS-WCS")
n = fc4.write(obj3)
self.assertEqual(n, 1)
del fc4
b = ss4.getSinkData()
self.assertEqual(a, b)
