def _update_observation_metadata(obs, headers, ngvs_name, uri):
"""
Why this method exists:
The NGVS weight files have almost no metadata in the primary HDU, but
all the needed metadata in subsequent HDUs.
It's not possible to apply extension
numbers for non-chunk blueprint entries, so that means that to use the
information captured in the blueprint, the header that's provided
must be manipulated instead. There is only access to the header
information in this extension of the fitscaom2 module (i.e. this file)
during the execution of the 'update' step of fits2caom2 execution.
Hence the self-referential implementation. Maybe it will result in an
infinite loop and I'll be sad.
"""
n_axis = headers[0].get('NAXIS')
if n_axis == 0:
logging.warning(f'Resetting the header/blueprint relationship for '
f'{ngvs_name.file_name} in {obs.observation_id}')
module = importlib.import_module(__name__)
blueprint = ObsBlueprint(module=module)
accumulate_bp(blueprint, uri)
tc.add_headers_to_obs_by_blueprint(
obs, [headers[1]], blueprint, uri, ngvs_name.product_id)
def test_add_headers_to_obs_by_blueprint(parser_mock):
test_blueprint = ObsBlueprint()
test_fqn = f'{test_conf.TEST_DATA_DIR}/translate_test/after_aug.xml'
test_obs = mc.read_obs_from_file(test_fqn)
test_product_id = '2515996g'
test_uri = 'ad:CFHT/2515996g.fits'
assert len(test_obs.planes) == 1, 'wrong number of planes'
assert (len(test_obs.planes[test_product_id].artifacts) == 1
), 'wrong number of artifacts'
assert (len(
test_obs.planes[test_product_id].artifacts[test_uri].parts) == 5
), 'wrong number of parts'
assert (len(
test_obs.planes[test_product_id].artifacts[test_uri].parts['0'].chunks)
== 1), 'wrong number of chunks'
assert (test_obs.planes[test_product_id].artifacts[test_uri].parts['0'].
chunks[0].naxis == 3), 'track initial value'
assert (test_obs.planes[test_product_id].artifacts[test_uri].
parts['IMAGE DATA'].chunks[0].naxis is None), 'track initial value'
tc.add_headers_to_obs_by_blueprint(test_obs, [], test_blueprint, test_uri,
test_product_id)
assert (len(
test_obs.planes[test_product_id].artifacts[test_uri].parts) == 5
), 'wrong number of parts'
assert (len(
test_obs.planes[test_product_id].artifacts[test_uri].parts['0'].chunks)
== 0), 'wrong number of chunks'
assert (len(
test_obs.planes[test_product_id].artifacts[test_uri].parts['1'].chunks)
== 1), 'wrong number of chunks'
assert (len(test_obs.planes[test_product_id].artifacts[test_uri].
parts['IMAGE DATA'].chunks) == 1), 'wrong number of chunks'
assert (test_obs.planes[test_product_id].artifacts[test_uri].
parts['IMAGE DATA'].chunks[0].naxis == 3), 'track initial value'
def test_augment_polarization(test_file):
test_fitsparser = FitsParser(test_file, ObsBlueprint(polarization_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
polarization = artifact.parts['0'].chunks[0].polarization
check_xml(ObservationWriter()._add_polarization_wcs_element, polarization,
EXPECTED_POLARIZATION_XML)
def test_chunk_naxis():
hdr1 = fits.Header()
test_blueprint = ObsBlueprint()
test_blueprint.configure_time_axis(3)
test_uri = 'ad:CFHT/1709071g.fits.gz'
test_defaults = {'CTYPE3': 'TIME'}
test_config = {'Chunk.naxis': 'chunk.naxis'}
test_overrides = {'chunk.naxis': '1'}
update_blueprint(test_blueprint,
test_uri,
config=test_config,
defaults=test_defaults,
overrides=test_overrides)
assert test_blueprint._get('Chunk.naxis') == '1', 'default value assigned'
FitsParser([hdr1], test_blueprint)
assert hdr1['NAXIS'] == 1
assert hdr1['ZNAXIS'] == 1
def test_augment_energy(test_file):
bp = ObsBlueprint(energy_axis=1)
test_fitsparser = FitsParser(test_file, bp)
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
energy = artifact.parts['0'].chunks[0].energy
energy.bandpassName = '21 cm' # user set attribute
check_xml(ObservationWriter()._add_spectral_wcs_element, energy,
EXPECTED_ENERGY_XML)
def test_class_apply_defaults(override_file):
ob = ObsBlueprint(position_axis=(1, 2),
energy_axis=3,
polarization_axis=4,
time_axis=5)
usc = {
'Plane.dataProductType': 'plane.dataProductType',
'Plane.provenance.producer': 'provenance.producer',
'Plane.provenance.project': 'provenance.project',
'Plane.metaRelease': 'plane.metaRelease',
'Plane.dataRelease': 'plane.dataRelease',
'Plane.calibrationLevel': 'plane.calibrationLevel',
'Observation.metaRelease': 'obs.metaRelease',
'Observation.intent': 'obs.intent',
'Observation.type': 'obs.type',
'Observation.proposal.pi': 'proposal.pi',
'Observation.proposal.project': 'proposal.project',
'Observation.proposal.title': 'proposal.title',
'Observation.sequenceNumber': 'obs.sequenceNumber',
'Observation.target.standard': 'target.standard',
'Artifact.productType': 'artifact.productType',
'Chunk.time.resolution': 'time.resolution',
'Chunk.time.exposure': 'time.exposure',
'Chunk.energy.resolvingPower': 'resolvingPower',
'Chunk.energy.bandpassName': 'filtername',
'Artifact.contentChecksum': 'artifact.contentChecksum'
}
convert = ConvertFromJava(ob, usc)
test_overrides = load_config(override_file)
for key, value in test_overrides.items():
try:
# artifacts is a substructure to be dealt with separately,
# WCSAXES should work .... ;)
if key == 'artifacts' or key == 'WCSAXES':
continue
result = convert.get_caom2_elements(key)
for r in result:
ob._get(r)
except ValueError:
assert False, 'Could not find key {} in ObsBlueprint'.format(key)
def test_augment_energy():
bp = ObsBlueprint(energy_axis=1)
test_fitsparser = FitsParser(sample_file_4axes, bp)
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
energy = artifact.parts['0'].chunks[0].energy
ex = _get_from_str_xml(EXPECTED_ENERGY_XML,
ObservationReader()._get_spectral_wcs, 'energy')
result = get_differences(ex, energy)
assert result is None, repr(energy)
def visit(self):
for uri, file_info in self._metadata_reader.file_info.items():
headers = self._metadata_reader.headers.get(uri)
telescope_data = Telescope(uri, headers)
blueprint = ObsBlueprint(instantiated_class=telescope_data)
telescope_data.accumulate_bp(blueprint)
if len(headers) == 0:
parser = GenericParser(blueprint, uri)
else:
parser = FitsParser(headers, blueprint, uri)
if self._dump_config:
print(f'Blueprint for {uri}: {blueprint}')
if self._observation is None:
if blueprint._get('DerivedObservation.members') is None:
self._logger.debug('Build a SimpleObservation')
self._observation = SimpleObservation(
collection=self._storage_name.collection,
observation_id=self._storage_name.obs_id,
algorithm=Algorithm('exposure'),
)
else:
self._logger.debug('Build a DerivedObservation')
self._observation = DerivedObservation(
collection=self._storage_name.collection,
observation_id=self._storage_name.obs_id,
algorithm=Algorithm('composite'),
)
parser.augment_observation(
observation=self._observation,
artifact_uri=uri,
product_id=self._storage_name.product_id,
)
self._observation = telescope_data.update(self._observation,
self._storage_name,
file_info)
return self._observation
def test_augment_polarization():
test_fitsparser = FitsParser(sample_file_4axes,
ObsBlueprint(polarization_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
polarization = artifact.parts['0'].chunks[0].polarization
ex = _get_from_str_xml(EXPECTED_POLARIZATION_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
result = get_differences(ex, polarization)
assert result is None, result
def test_class_apply_defaults(override_file):
ob = ObsBlueprint(position_axes=(1, 2), energy_axis=3,
polarization_axis=4, time_axis=5)
usc = {'Plane.dataProductType': 'plane.dataProductType',
'Plane.provenance.producer': 'provenance.producer',
'Plane.provenance.project': 'provenance.project',
'Plane.metaRelease': 'plane.metaRelease',
'Plane.dataRelease': 'plane.dataRelease',
'Plane.calibrationLevel': 'plane.calibrationLevel',
'Observation.metaRelease': 'obs.metaRelease',
'Observation.intent': 'obs.intent',
'Observation.type': 'obs.type',
'Observation.proposal.pi': 'proposal.pi',
'Observation.proposal.project': 'proposal.project',
'Observation.proposal.title': 'proposal.title',
'Observation.sequenceNumber': 'obs.sequenceNumber',
'Observation.target.standard': 'target.standard',
'Artifact.productType': 'artifact.productType',
'Chunk.time.resolution': 'time.resolution',
'Chunk.time.exposure': 'time.exposure',
'Chunk.energy.resolvingPower': 'resolvingPower',
'Chunk.energy.bandpassName': 'filtername',
'Artifact.contentChecksum': 'artifact.contentChecksum'
}
convert = ConvertFromJava(ob, usc)
test_overrides = load_config(override_file)
for key, value in test_overrides.items():
try:
# artifacts is a substructure to be dealt with separately,
# WCSAXES should work .... ;)
if key == 'artifacts' or key == 'WCSAXES':
continue
result = convert.get_caom2_elements(key)
for r in result:
ob._get(r)
except ValueError:
assert False, 'Could not find key {} in ObsBlueprint'.format(key)
def test_augment_artifact_time(test_file, expected):
test_fitsparser = FitsParser(test_file, ObsBlueprint(time_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 6
test_part = artifact.parts['1']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.time is not None
check_xml(ObservationWriter()._add_temporal_wcs_element, test_chunk.time,
expected)
def test_augment_artifact(test_file):
test_fitsparser = FitsParser(test_file, ObsBlueprint(position_axis=(1, 2)))
artifact = Artifact('ad:{}/{}'.format('TEST', test_file),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 1
test_part = artifact.parts['0']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.position is not None
check_xml(ObservationWriter()._add_spatial_wcs_element,
test_chunk.position, EXPECTED_POSITION_XML)
def test_visit():
test_obs = _get_obs(EXPECTED_FILE_SCHEME_XML)
with pytest.raises(ImportError):
_load_plugin('nonexistent.py')
with pytest.raises(ImportError):
_load_plugin(non_conformant_plugin_module)
test_fitsparser = FitsParser(sample_file_4axes,
ObsBlueprint(polarization_axis=1))
kwargs = {}
_visit(test_plugin_module, test_fitsparser, test_obs, **kwargs)
_visit(test_class_plugin_module, test_fitsparser, test_obs, **kwargs)
def _build_blueprints(uri):
"""This application relies on the caom2utils fits2caom2 ObsBlueprint
definition for mapping FITS file values to CAOM model element
attributes. This method builds the DRAO-ST blueprint for a single
artifact.
The blueprint handles the mapping of values with cardinality of 1:1
between the blueprint entries and the model attributes.
:param uri The artifact URI for the file to be processed."""
module = importlib.import_module(__name__)
blueprint = ObsBlueprint(module=module)
accumulate_bp(blueprint, uri)
blueprints = {uri: blueprint}
return blueprints
def test_augment_artifact_time():
test_fitsparser = FitsParser(sample_file_time_axes,
ObsBlueprint(time_axis=1))
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_time_axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 6
test_part = artifact.parts['1']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.time is not None
ex = _get_from_str_xml(EXPECTED_CFHT_WIRCAM_RAW_GUIDE_CUBE_TIME,
ObservationReader()._get_temporal_wcs, 'time')
result = get_differences(ex, test_chunk.time)
assert result is None
def test_augment_artifact():
test_blueprint = ObsBlueprint(position_axes=(1, 2))
test_fitsparser = FitsParser(sample_file_4axes, test_blueprint)
artifact = Artifact('ad:{}/{}'.format('TEST', sample_file_4axes),
ProductType.SCIENCE, ReleaseType.DATA)
test_fitsparser.augment_artifact(artifact)
assert artifact.parts is not None
assert len(artifact.parts) == 1
test_part = artifact.parts['0']
test_chunk = test_part.chunks.pop()
assert test_chunk is not None
assert test_chunk.position is not None
ex = _get_from_str_xml(EXPECTED_POSITION_XML,
ObservationReader()._get_spatial_wcs, 'position')
result = get_differences(ex, test_chunk.position)
assert result is None
def _build_blueprints(uris):
"""This application relies on the caom2utils fits2caom2 ObsBlueprint
definition for mapping FITS file values to CAOM model element
attributes. This method builds the DRAO-ST blueprint for a single
artifact.
The blueprint handles the mapping of values with cardinality of 1:1
between the blueprint entries and the model attributes.
:param uris The artifact URIs for the files to be processed."""
module = importlib.import_module(__name__)
blueprints = {}
for uri in uris:
blueprint = ObsBlueprint(module=module, update=True)
if not mc.StorageName.is_preview(uri):
accumulate_bp(blueprint, uri)
blueprints[uri] = blueprint
return blueprints
def build_blueprints(args):
"""This application relies on the caom2utils fits2caom2 ObsBlueprint
definition for mapping FITS file values to CAOM model element
attributes. This method builds the VLASS blueprint for a single
artifact.
The blueprint handles the mapping of values with cardinality of 1:1
between the blueprint entries and the model attributes.
:param args """
module = importlib.import_module(__name__)
blueprints = {}
for ii in args.lineage:
blueprint = ObsBlueprint(module=module)
accumulate_wcs(blueprint)
product_id, artifact_uri = mc.decompose_lineage(ii)
blueprints[artifact_uri] = blueprint
return blueprints
def draw_cgps_blueprint(uri, headers, local, cert):
"""
Modify an ObsBlueprint instance.
:param uri: Which URI defines the structure of the blueprint.
:param headers: astropy headers structure containing the metadata for
the subject of blueprint construction.
:param local: Files on disk, conditionally.
:param cert: X509 certificate for accessing proprietary metadata from
CADC services.
:return: The blueprint, customized according to the input data.
"""
logging.debug(f'Begin blueprint customization for CGPS {uri}.')
blueprint = ObsBlueprint()
_metadata_from(blueprint, headers, uri, local, cert)
_set_defaults_and_overrides(blueprint)
logging.debug(f'Blueprint customatization complete for CGPS {uri}.')
return blueprint
def test_augment_artifact_position_from_blueprint():
test_blueprint = ObsBlueprint(position_axes=(1, 2))
test_blueprint.set('Chunk.positionAxis1', '1')
test_blueprint.set('Chunk.positionAxis2', '2')
test_blueprint.set('Chunk.position.axis.axis1.ctype', 'GLON-CAR')
test_blueprint.set('Chunk.position.axis.axis1.cunit', 'deg')
test_blueprint.set('Chunk.position.axis.axis2.ctype', 'GLAT-CAR')
test_blueprint.set('Chunk.position.axis.axis2.cunit', 'deg')
test_blueprint.set('Chunk.position.axis.function.cd11', '-0.004999999')
test_blueprint.set('Chunk.position.axis.function.cd12', '0.0')
test_blueprint.set('Chunk.position.axis.function.cd21', '0.0')
test_blueprint.set('Chunk.position.axis.function.cd22', '0.004999999')
test_blueprint.set('Chunk.position.axis.function.dimension.naxis1', '1')
test_blueprint.set('Chunk.position.axis.function.dimension.naxis2', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord1.pix', '513.0')
test_blueprint.set('Chunk.position.axis.range.start.coord1.val',
'128.7499990027')
test_blueprint.set('Chunk.position.axis.range.start.coord2.pix', '513.0')
test_blueprint.set('Chunk.position.axis.range.start.coord2.val',
'-0.9999999922536')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='test_parser')
test_chunk = Chunk()
test_fitsparser._try_position_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_POSITION_XML,
ObservationReader()._get_spatial_wcs, 'position')
result = get_differences(ex, test_chunk.position)
assert result is None
def test_augment_artifact_polarization_from_blueprint():
test_blueprint = ObsBlueprint(polarization_axis=1)
test_blueprint.set('Chunk.polarizationAxis', '1')
test_blueprint.set('Chunk.polarization.axis.axis.ctype', 'STOKES')
test_blueprint.set('Chunk.polarization.axis.function.refCoord.pix', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.refCoord.val', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.delta', '1.0')
test_blueprint.set('Chunk.polarization.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='test_parser')
test_chunk = Chunk()
test_fitsparser._try_polarization_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_POLARIZATION_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
result = get_differences(ex, test_chunk.polarization)
assert result is None
def test_obs_blueprint():
# test the CAOM2_ELEMENTS property
assert ObsBlueprint.CAOM2_ELEMENTS == ObsBlueprint._CAOM2_ELEMENTS
# updating the CAOM2_ELEMENTS property should not update the original
elems = ObsBlueprint.CAOM2_ELEMENTS
elems = elems[2:]
assert elems != ObsBlueprint.CAOM2_ELEMENTS
# default config (one entry per row...)
assert str(ObsBlueprint()).count('\n') == 21
print(ObsBlueprint())
# default config with WCS info
assert str(ObsBlueprint(position_axes=(1, 2), energy_axis=3,
polarization_axis=4, time_axis=5,
obs_axis=6)).count('\n') == 81
ob = ObsBlueprint()
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
ob.configure_observable_axis(axis=6)
# test that configuring something that's already configured doesn't break
# anything
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
ob.configure_observable_axis(axis=6)
# set attribute
ob.set('Observation.instrument.name', 'NIRI')
assert ob._plan['Observation.instrument.name'] == 'NIRI'
assert 'Observation.instrument.name = NIRI' in str(ob)
# set default
ob.clear('Observation.instrument.keywords')
ob.add_fits_attribute('Observation.instrument.keywords', str('INSTMODE'))
assert "Observation.instrument.keywords = ['INSTMODE'], default = None" \
in str(ob)
ob.set_default('Observation.instrument.keywords', 'TEST')
assert ob._plan['Observation.instrument.keywords'][1] == 'TEST'
assert ob._plan['Observation.instrument.keywords'][0] == ['INSTMODE']
assert "Observation.instrument.keywords = ['INSTMODE'], default = TEST" \
in str(ob)
# set fits attribute
ob.add_fits_attribute('Observation.proposal.id', str('PROP'))
ob.add_fits_attribute('Observation.proposal.id', str('PROP2'))
ob.set_default('Observation.proposal.id', 'NOPROP')
assert ob._plan['Observation.proposal.id'][0] == ['PROP2', 'PROP', 'RUNID']
assert ob._plan['Observation.proposal.id'][1] == 'NOPROP'
if sys.version.startswith('2.7.'):
assert ("Observation.proposal.id = ['PROP2', 'PROP', u'RUNID'], "
"default = NOPROP") in str(ob)
else:
assert ("Observation.proposal.id = ['PROP2', 'PROP', 'RUNID'], "
"default = NOPROP") in str(ob)
# set in extension
ob.set('Chunk.energy.velang', 33, extension=1)
extension1_str = str(ob)[str(ob).index('extension 1'):]
assert 'Chunk.energy.velang = 33' in extension1_str
# set fits attribute in extension
ob.add_fits_attribute('Chunk.energy.axis.axis.ctype', str('MYCTYPE'),
extension=1)
ob.add_fits_attribute('Chunk.energy.axis.axis.ctype', str('MYCTYPE2'),
extension=1)
ob.set_default('Chunk.energy.axis.axis.ctype', 'NOCTYPE', extension=1)
extension1_str = str(ob)[str(ob).index('extension 1'):]
assert ("Chunk.energy.axis.axis.ctype = ['MYCTYPE2', 'MYCTYPE'], "
"default = NOCTYPE") in extension1_str
# set in a different extension
ob.set('Chunk.energy.velang', 44, extension=2)
extension2_str = str(ob)[str(ob).index('extension 2'):]
assert 'Chunk.energy.velang = 44' in extension2_str
# test get
assert ob._get('Observation.instrument.name') == 'NIRI'
assert ob._get('Observation.instrument.keywords')[0] == ['INSTMODE']
assert ob._get('Observation.instrument.keywords')[1] == 'TEST'
assert ob._get('Chunk.energy.velang', extension=2) == 44
assert ob._get('Chunk.energy.velang', extension=1) == 33
assert ob._get('Chunk.energy.axis.axis.ctype', extension=1)[0] ==\
['MYCTYPE2', 'MYCTYPE']
assert ob._get('Chunk.energy.axis.axis.ctype', extension=1)[1] == 'NOCTYPE'
# test get when keyword not present in extension and the default is used
assert ob._get('Chunk.energy.specsys', extension=33)[0] == ['SPECSYS']
assert ob._get('Chunk.energy.specsys', extension=44)[1] is None
# get element not set
assert 'Observation.target.redshift' not in ob._plan
assert ob._get('Observation.target.redshift') is None
# bintable :)
ob.add_table_attribute('CompositeObservation.members', 'FICS', extension=0)
result = ob._get('CompositeObservation.members', extension=0)
assert result is not None
assert len(result) == 3, len(result)
# delete attributes
assert len(ob._plan) != 0
assert len(ob._extensions) != 0
for i in ObsBlueprint.CAOM2_ELEMENTS:
ob.delete(i)
assert len(ob._plan) == 0
# clear
ob.clear('Chunk.energy.axis.axis.ctype', extension=1)
# delete attributes from extensions
ob.delete('Chunk.energy.velang', extension=1)
ob.delete('Chunk.energy.axis.axis.ctype', extension=1)
ob.delete('CompositeObservation.members', extension=0)
ob.delete('Chunk.energy.velang', extension=2)
assert len(ob._extensions) == 0
# testing error cases
ob = ObsBlueprint()
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
# non CAOM2 element name
with pytest.raises(KeyError):
ob.set('Nonexistent', 33)
with pytest.raises(KeyError):
ob.add_fits_attribute('Nonexistent', 33)
with pytest.raises(KeyError):
ob.set_default('Nonexistent', 33)
with pytest.raises(KeyError):
ob._get('Nonexistent')
with pytest.raises(KeyError):
ob.delete('Nonexistent')
with pytest.raises(KeyError):
ob.clear('Nonexistent')
# repeat with extension specified
with pytest.raises(KeyError):
ob.set('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob.add_fits_attribute('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob.set_default('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob._get('Nonexistent', extension=33)
with pytest.raises(KeyError):
ob.delete('Chunk.Nonexistent', extension=1)
with pytest.raises(KeyError):
ob.clear('Chunk.Nonexistent', extension=1)
# CAOM2 element not Chunk with extension specified
with pytest.raises(ValueError):
ob.set('Observation.observationID', 33, extension=1)
with pytest.raises(ValueError):
ob.set_default('Observation.observationID', 33, extension=1)
with pytest.raises(ValueError):
ob.add_fits_attribute('Observation.observationID', 'AA', extension=1)
with pytest.raises(ValueError):
ob.delete('Observation.observationID', extension=1)
with pytest.raises(ValueError):
ob.clear('Observation.observationID', extension=1)
# CAOM2 element Chunk with extension
with pytest.raises(ValueError):
ob.clear('Chunk.energy.axis.axis.cunit', extension=33)
# add FITS attribute to element that does not exist
assert 'Chunk.energy.transition' not in ob._plan
ob.set('Chunk.energy.transition', 'Name')
with pytest.raises(AttributeError):
ob.add_fits_attribute('Chunk.energy.transition', 'BP')
# call set_fits_attribute with argument other than list
with pytest.raises(AttributeError):
ob.add_fits_attribute('Chunk.energy.transition', 33)
# delete element from a non-existent extension
with pytest.raises(ValueError):
ob.delete('Chunk.energy.transition', extension=66)
# adding the same thing twice does nothing - the test values are defaults
result = ob._get('Observation.metaRelease')
initial_result_length = (len(result[0]))
ob.add_fits_attribute('Observation.metaRelease', 'DATE-OBS')
result = ob._get('Observation.metaRelease')
add_result_length = (len(result[0]))
assert initial_result_length == add_result_length
# in an extension
result = ob._get('Chunk.energy.specsys', extension=1)
initial_result_length = (len(result[0]))
ob.add_fits_attribute('Chunk.energy.specsys', 'SPECSYS')
result = ob._get('Chunk.energy.specsys', extension=1)
add_result_length = (len(result[0]))
assert initial_result_length == add_result_length, result
def test_get_from_list():
test_fitsparser = FitsParser(sample_file_4axes)
test_fitsparser.blueprint = ObsBlueprint()
result = test_fitsparser._get_from_list('Observation.intent', 0,
ObservationIntentType.SCIENCE)
assert result == ObservationIntentType.SCIENCE
def test_augment_artifact_bounds_range_from_blueprint():
test_blueprint = ObsBlueprint(energy_axis=1,
time_axis=2,
polarization_axis=3,
position_axes=(4, 5))
test_blueprint.set('Chunk.energy.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.energy.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.energy.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.energy.axis.range.end.val', '1')
test_blueprint.set('Chunk.time.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.time.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.time.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.time.axis.range.end.val', '1')
test_blueprint.set('Chunk.polarization.axis.range.start.pix', '145.0')
test_blueprint.set('Chunk.polarization.axis.range.start.val', '-60000.0')
test_blueprint.set('Chunk.polarization.axis.range.end.pix', '-824.46002')
test_blueprint.set('Chunk.polarization.axis.range.end.val', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord1.pix', '145.0')
test_blueprint.set('Chunk.position.axis.range.start.coord1.val',
'-60000.0')
test_blueprint.set('Chunk.position.axis.range.end.coord1.pix',
'-824.46002')
test_blueprint.set('Chunk.position.axis.range.end.coord1.val', '1')
test_blueprint.set('Chunk.position.axis.range.start.coord2.pix', '145.0')
test_blueprint.set('Chunk.position.axis.range.start.coord2.val',
'-60000.0')
test_blueprint.set('Chunk.position.axis.range.end.coord2.pix',
'-824.46002')
test_blueprint.set('Chunk.position.axis.range.end.coord2.val', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_chunk.energy = SpectralWCS(CoordAxis1D(Axis('WAVE', 'm')), 'TOPOCENT')
test_chunk.time = TemporalWCS(CoordAxis1D(Axis('TIME', 'd')))
test_chunk.polarization = PolarizationWCS(CoordAxis1D(Axis('STOKES')))
test_chunk.position = SpatialWCS(
CoordAxis2D(Axis('RA', 'deg'), Axis('DEC', 'deg')))
test_fitsparser._try_range_with_blueprint(test_chunk, 0)
assert test_chunk.energy.axis.range is not None, \
'chunk.energy.axis.range should be declared'
assert test_chunk.time.axis.range is not None, \
'chunk.time.axis.range should be declared'
assert test_chunk.polarization.axis.range is not None, \
'chunk.polarization.axis.range should be declared'
assert test_chunk.position.axis.range is not None, \
'chunk.position.axis.range should be declared'
ex = _get_from_str_xml(EXPECTED_ENERGY_RANGE_BOUNDS_XML,
ObservationReader()._get_spectral_wcs, 'energy')
assert ex is not None, \
'energy string from expected output should be declared'
result = get_differences(ex, test_chunk.energy)
assert result is None
ex = _get_from_str_xml(EXPECTED_TIME_RANGE_BOUNDS_XML,
ObservationReader()._get_temporal_wcs, 'time')
assert ex is not None, \
'time string from expected output should be declared'
result = get_differences(ex, test_chunk.time)
assert result is None
ex = _get_from_str_xml(EXPECTED_POL_RANGE_BOUNDS_XML,
ObservationReader()._get_polarization_wcs,
'polarization')
assert ex is not None, \
'polarization string from expected output should be declared'
result = get_differences(ex, test_chunk.polarization)
assert result is None
ex = _get_from_str_xml(EXPECTED_POS_RANGE_BOUNDS_XML,
ObservationReader()._get_spatial_wcs, 'position')
assert ex is not None, \
'position string from expected output should be declared'
result = get_differences(ex, test_chunk.position)
assert result is None
def test_obs_blueprint():
# test the CAOM2_ELEMENTS property
assert ObsBlueprint.CAOM2_ELEMENTS == ObsBlueprint._CAOM2_ELEMENTS
# updating the CAOM2_ELEMENTS property should not update the original
elems = ObsBlueprint.CAOM2_ELEMENTS
elems = elems[2:]
assert elems != ObsBlueprint.CAOM2_ELEMENTS
# default config (one entry per row...)
assert str(ObsBlueprint()).count('\n') == 24
print(ObsBlueprint())
# default config with WCS info
assert str(
ObsBlueprint(position_axes=(1, 2),
energy_axis=3,
polarization_axis=4,
time_axis=5,
obs_axis=6,
custom_axis=7)).count('\n') == 90
ob = ObsBlueprint()
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
ob.configure_observable_axis(axis=6)
ob.configure_custom_axis(axis=7)
# test that configuring something that's already configured doesn't break
# anything
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
ob.configure_observable_axis(axis=6)
ob.configure_custom_axis(axis=7)
# set attribute
ob.set('Observation.instrument.name', 'NIRI')
assert ob._plan['Observation.instrument.name'] == 'NIRI'
assert 'Observation.instrument.name = NIRI' in str(ob)
# set default
ob.clear('Observation.instrument.keywords')
ob.add_fits_attribute('Observation.instrument.keywords', 'INSTMODE')
assert "Observation.instrument.keywords = ['INSTMODE'], default = None" \
in str(ob)
ob.set_default('Observation.instrument.keywords', 'TEST')
assert ob._plan['Observation.instrument.keywords'][1] == 'TEST'
assert ob._plan['Observation.instrument.keywords'][0] == ['INSTMODE']
assert "Observation.instrument.keywords = ['INSTMODE'], default = TEST" \
in str(ob)
# set fits attribute
ob.add_fits_attribute('Observation.proposal.id', 'PROP')
ob.add_fits_attribute('Observation.proposal.id', 'PROP2')
ob.set_default('Observation.proposal.id', 'NOPROP')
assert ob._plan['Observation.proposal.id'][0] == ['PROP2', 'PROP', 'RUNID']
assert ob._plan['Observation.proposal.id'][1] == 'NOPROP'
if sys.version.startswith('2.7.'):
assert ("Observation.proposal.id = ['PROP2', 'PROP', u'RUNID'], "
"default = NOPROP") in str(ob)
else:
assert ("Observation.proposal.id = ['PROP2', 'PROP', 'RUNID'], "
"default = NOPROP") in str(ob)
# set in extension
ob.set('Chunk.energy.velang', 33, extension=1)
extension1_str = str(ob)[str(ob).index('extension 1'):]
assert 'Chunk.energy.velang = 33' in extension1_str
# set fits attribute in extension
ob.add_fits_attribute('Chunk.energy.axis.axis.ctype',
'MYCTYPE',
extension=1)
ob.add_fits_attribute('Chunk.energy.axis.axis.ctype',
'MYCTYPE2',
extension=1)
ob.set_default('Chunk.energy.axis.axis.ctype', 'NOCTYPE', extension=1)
extension1_str = str(ob)[str(ob).index('extension 1'):]
assert ("Chunk.energy.axis.axis.ctype = ['MYCTYPE2', 'MYCTYPE'], "
"default = NOCTYPE") in extension1_str
# set in a different extension
ob.set('Chunk.energy.velang', 44, extension=2)
extension2_str = str(ob)[str(ob).index('extension 2'):]
assert 'Chunk.energy.velang = 44' in extension2_str
# test get
assert ob._get('Observation.instrument.name') == 'NIRI'
assert ob._get('Observation.instrument.keywords')[0] == ['INSTMODE']
assert ob._get('Observation.instrument.keywords')[1] == 'TEST'
assert ob._get('Chunk.energy.velang', extension=2) == 44
assert ob._get('Chunk.energy.velang', extension=1) == 33
assert ob._get('Chunk.energy.axis.axis.ctype', extension=1)[0] ==\
['MYCTYPE2', 'MYCTYPE']
assert ob._get('Chunk.energy.axis.axis.ctype', extension=1)[1] == 'NOCTYPE'
# test get when keyword not present in extension and the default is used
assert ob._get('Chunk.energy.specsys', extension=33)[0] == ['SPECSYS']
assert ob._get('Chunk.energy.specsys', extension=44)[1] is None
# get element not set
assert 'Observation.target.redshift' not in ob._plan
assert ob._get('Observation.target.redshift') is None
# bintable :)
ob.add_table_attribute('CompositeObservation.members', 'FICS', extension=0)
result = ob._get('CompositeObservation.members', extension=0)
assert result is not None
assert len(result) == 3, len(result)
# delete attributes
assert len(ob._plan) != 0
assert len(ob._extensions) != 0
for i in ObsBlueprint.CAOM2_ELEMENTS:
ob.delete(i)
assert len(ob._plan) == 0
# clear
ob.clear('Chunk.energy.axis.axis.ctype', extension=1)
# delete attributes from extensions
ob.delete('Chunk.energy.velang', extension=1)
ob.delete('Chunk.energy.axis.axis.ctype', extension=1)
ob.delete('CompositeObservation.members', extension=0)
ob.delete('Chunk.energy.velang', extension=2)
assert len(ob._extensions) == 0
# set defaults in extension
ob.set_default('Chunk.energy.axis.axis.ctype', 'NOCTYPE', extension=3)
extension3_str = str(ob)[str(ob).index('extension 3'):]
assert "Chunk.energy.axis.axis.ctype = NOCTYPE" in extension3_str
assert len(ob._extensions) == 1
# testing error cases
ob = ObsBlueprint()
ob.configure_position_axes(axes=(1, 2))
ob.configure_energy_axis(axis=3)
ob.configure_polarization_axis(axis=4)
ob.configure_time_axis(axis=5)
# non CAOM2 element name
with pytest.raises(KeyError):
ob.set('Nonexistent', 33)
with pytest.raises(KeyError):
ob.add_fits_attribute('Nonexistent', 33)
with pytest.raises(KeyError):
ob.set_default('Nonexistent', 33)
with pytest.raises(KeyError):
ob._get('Nonexistent')
with pytest.raises(KeyError):
ob.delete('Nonexistent')
with pytest.raises(KeyError):
ob.clear('Nonexistent')
# repeat with extension specified
with pytest.raises(KeyError):
ob.set('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob.add_fits_attribute('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob.set_default('Chunk.Nonexistent', 33, extension=1)
with pytest.raises(KeyError):
ob._get('Nonexistent', extension=33)
with pytest.raises(KeyError):
ob.delete('Chunk.Nonexistent', extension=1)
with pytest.raises(KeyError):
ob.clear('Chunk.Nonexistent', extension=1)
# CAOM2 element not Chunk with extension specified
with pytest.raises(ValueError):
ob.set('Observation.observationID', 33, extension=1)
with pytest.raises(ValueError):
ob.set_default('Observation.observationID', 33, extension=1)
with pytest.raises(ValueError):
ob.add_fits_attribute('Observation.observationID', 'AA', extension=1)
with pytest.raises(ValueError):
ob.delete('Observation.observationID', extension=1)
with pytest.raises(ValueError):
ob.clear('Observation.observationID', extension=1)
# CAOM2 element Chunk with extension
with pytest.raises(ValueError):
ob.clear('Chunk.energy.axis.axis.cunit', extension=33)
# add FITS attribute to element that does not exist
assert 'Chunk.energy.transition' not in ob._plan
ob.set('Chunk.energy.transition', 'Name')
with pytest.raises(AttributeError):
ob.add_fits_attribute('Chunk.energy.transition', 'BP')
# call set_fits_attribute with argument other than list
with pytest.raises(AttributeError):
ob.add_fits_attribute('Chunk.energy.transition', 33)
# delete element from a non-existent extension
with pytest.raises(ValueError):
ob.delete('Chunk.energy.transition', extension=66)
# adding the same thing twice does nothing - the test values are defaults
result = ob._get('Observation.metaRelease')
initial_result_length = (len(result[0]))
ob.add_fits_attribute('Observation.metaRelease', 'DATE-OBS')
result = ob._get('Observation.metaRelease')
add_result_length = (len(result[0]))
assert initial_result_length == add_result_length
# in an extension
result = ob._get('Chunk.energy.specsys', extension=1)
initial_result_length = (len(result[0]))
ob.add_fits_attribute('Chunk.energy.specsys', 'SPECSYS')
result = ob._get('Chunk.energy.specsys', extension=1)
add_result_length = (len(result[0]))
assert initial_result_length == add_result_length, result
def test_ctor_failure():
with pytest.raises(ValueError):
ObsBlueprint(position_axes=(1, 2, 3))
def test_load_from_file_configure():
ob = ObsBlueprint()
assert not ob._pos_axes_configed, \
'Failure to initialize configure_position_axes'
assert not ob._energy_axis_configed, \
'Failure to initialize configure_energy_axis'
assert not ob._custom_axis_configed, 'custom config'
assert not ob._obs_axis_configed, 'obs config'
assert not ob._polarization_axis_configed, 'pol config'
assert not ob._time_axis_configed, 'time config'
ob.add_fits_attribute('Chunk.position.axis.axis1.ctype', 'CTYPE1')
ob.add_fits_attribute('Chunk.position.axis.axis2.ctype', 'CTYPE2')
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._pos_axes_configed, 'Failure to call configure_position_axes'
assert ob._energy_axis_configed, 'Failure to call configure_energy_axis'
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE3', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
ob = ObsBlueprint()
ob.add_fits_attribute('Chunk.position.axis.axis1.ctype', 'CTYPE3')
ob.add_fits_attribute('Chunk.position.axis.axis2.ctype', 'CTYPE4')
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._pos_axes_configed, 'Failure to call configure_position_axes'
assert ob._energy_axis_configed, 'Failure to call configure_energy_axis'
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE1', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
ob = ObsBlueprint()
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE3', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
ob = ObsBlueprint()
ob.set('Chunk.polarization.axis.axis.ctype', 'STOKES')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.polarization.axis.axis.ctype'] == 'CTYPE5', \
ob._wcs_std['Chunk.polarization.axis.axis.ctype']
assert ob._polarization_axis_configed, 'pol config'
ob = ObsBlueprint()
ob.set('Chunk.observable.axis.axis.ctype', 'COUNT')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.observable.axis.axis.ctype'] == 'CTYPE6', \
ob._wcs_std['Chunk.observable.axis.axis.ctype']
assert ob._obs_axis_configed, 'obs config'
ob = ObsBlueprint()
ob.set('Chunk.custom.axis.axis.ctype', 'FARDEP')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.custom.axis.axis.ctype'] == 'CTYPE7', \
ob._wcs_std['Chunk.custom.axis.axis.ctype']
assert ob._custom_axis_configed, 'custom config'
ob = ObsBlueprint()
ob.set('Chunk.time.axis.axis.ctype', 'TIME')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.time.axis.axis.ctype'] == 'CTYPE4', \
ob._wcs_std['Chunk.time.axis.axis.ctype']
assert ob._time_axis_configed, 'time config'
# should get the position axes by default
ob = ObsBlueprint()
ob._guess_axis_info_from_plan()
assert ob._pos_axes_configed, 'pos config'
assert not ob._energy_axis_configed, 'energy config'
assert not ob._custom_axis_configed, 'custom config'
assert not ob._obs_axis_configed, 'obs config'
assert not ob._polarization_axis_configed, 'pol config'
assert not ob._time_axis_configed, 'time config'
# for the truly creative instrument scientist
ob = ObsBlueprint()
ob.add_fits_attribute('Chunk.polarization.axis.axis.ctype', 'CTYPE1')
ob.add_fits_attribute('Chunk.custom.axis.axis.ctype', 'CTYPE2')
ob.add_fits_attribute('Chunk.position.axis.axis1.ctype', 'CTYPE3')
ob.add_fits_attribute('Chunk.position.axis.axis2.ctype', 'CTYPE4')
ob.add_fits_attribute('Chunk.time.axis.axis.ctype', 'CTYPE5')
ob.add_fits_attribute('Chunk.energy.axis.axis.ctype', 'CTYPE6')
ob.add_fits_attribute('Chunk.observable.axis.axis.ctype', 'CTYPE7')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.polarization.axis.axis.ctype'] == 'CTYPE1', \
ob._wcs_std['Chunk.polarization.axis.axis.ctype']
assert ob._wcs_std['Chunk.custom.axis.axis.ctype'] == 'CTYPE2', \
ob._wcs_std['Chunk.custom.axis.axis.ctype']
assert ob._wcs_std['Chunk.position.axis.axis1.ctype'] == 'CTYPE3', \
ob._wcs_std['Chunk.position.axis.axis1.ctype']
assert ob._wcs_std['Chunk.position.axis.axis2.ctype'] == 'CTYPE4', \
ob._wcs_std['Chunk.position.axis.axis2.ctype']
assert ob._wcs_std['Chunk.time.axis.axis.ctype'] == 'CTYPE5', \
ob._wcs_std['Chunk.time.axis.axis.ctype']
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE6', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
assert ob._wcs_std['Chunk.observable.axis.axis.ctype'] == 'CTYPE7', \
ob._wcs_std['Chunk.observable.axis.axis.ctype']
with pytest.raises(ValueError):
ob = ObsBlueprint()
ob.add_fits_attribute('Chunk.polarization.axis.axis.ctype', 'CTYPE1')
ob._guess_axis_info_from_plan()
def test_augment_artifact_time_from_blueprint():
test_blueprint = ObsBlueprint(time_axis=1)
test_blueprint.set('Chunk.timeAxis', '1')
test_blueprint.set('Chunk.time.exposure', '0.02')
test_blueprint.set('Chunk.time.resolution', '0.02')
test_blueprint.set('Chunk.time.timesys', 'UTC')
test_blueprint.set('Chunk.time.axis.axis.ctype', 'TIME')
test_blueprint.set('Chunk.time.axis.axis.cunit', 'd')
test_blueprint.set('Chunk.time.axis.error.syser', '1e-07')
test_blueprint.set('Chunk.time.axis.error.rnder', '1e-07')
test_blueprint.set('Chunk.time.axis.function.refCoord.pix', '0.5')
test_blueprint.set('Chunk.time.axis.function.refCoord.val',
'56789.4298069')
test_blueprint.set('Chunk.time.axis.function.delta', '2.31481e-07')
test_blueprint.set('Chunk.time.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_fitsparser._try_time_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_CFHT_WIRCAM_RAW_GUIDE_CUBE_TIME,
ObservationReader()._get_temporal_wcs, 'time')
result = get_differences(ex, test_chunk.time)
assert result is None
def test_augment_observation():
test_obs_blueprint = ObsBlueprint(position_axes=(1, 2))
test_obs_blueprint.set('Observation.target.name', 'CGPS Mosaic MA1')
test_obs_blueprint.set('Observation.target.standard', False)
test_obs_blueprint.set('Observation.telescope.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.instrument.name', 'DRAO-ST')
test_obs_blueprint.set('Observation.telescope.geoLocationX',
'-2100330.87517')
test_obs_blueprint.set('Observation.telescope.geoLocationY',
'-3694247.82445')
test_obs_blueprint.set('Observation.telescope.geoLocationZ',
'4741018.33097')
test_obs_blueprint.set('Plane.dataProductType', 'cube')
test_obs_blueprint.set('Artifact.productType', 'info')
test_obs_blueprint.set('Artifact.releaseType', 'data')
test_obs_blueprint.set('Plane.calibrationLevel', '2')
test_fitsparser = FitsParser(sample_file_4axes_obs, test_obs_blueprint)
test_fitsparser.blueprint = test_obs_blueprint
test_obs = SimpleObservation('collection', 'MA1_DRAO-ST',
Algorithm('exposure'))
test_fitsparser.augment_observation(test_obs,
sample_file_4axes_uri,
product_id='HI-line')
assert test_obs is not None
assert test_obs.planes is not None
assert len(test_obs.planes) == 1
test_plane = test_obs.planes['HI-line']
assert test_plane.artifacts is not None
assert len(test_plane.artifacts) == 1
test_artifact = test_plane.artifacts[sample_file_4axes_uri]
assert test_artifact is not None
test_part = test_artifact.parts['0']
# remove the chunk bit, as it's part of other tests -
# results in <caom2:chunks/> xml output
test_part.chunks.pop()
output = BytesIO()
ow = ObservationWriter(False, False, "caom2",
obs_reader_writer.CAOM20_NAMESPACE)
ow.write(test_obs, output)
result = output.getvalue().decode('UTF-8')
output.close()
expected = _get_obs(EXPECTED_OBS_XML)
actual = _get_obs(result)
diff_result = get_differences(expected, actual, 'Observation')
assert diff_result is None
def test_has_chunk():
# the CFHT case
ob = ObsBlueprint()
ob.configure_position_axes((1, 2))
ob.set('Chunk', '{ignore}')
ob.set('Chunk.position.axis.axis1.ctype', 'RA---SIN', 1)
assert not ob.has_chunk(0)
assert ob.has_chunk(1)
# the OMM case
ob = ObsBlueprint()
ob.configure_position_axes((1, 2))
ob.set('Chunk', '{ignore}', 1)
assert ob.has_chunk(0)
assert not ob.has_chunk(1)
def test_update_fits_headers():
# The rules for the values:
# all upper case - a FITS keyword
# has an '{' or an '}' - a FITS keyword with an index
#
# The rules for the keys:
# has a '.' - a config keyword
# all upper case - a FITS keyword
hdr1 = fits.Header()
hdr2 = fits.Header()
hdr3 = fits.Header()
hdr4 = fits.Header()
hdr5 = fits.Header()
hdr6 = fits.Header()
hdr7 = fits.Header()
test_blueprint = ObsBlueprint()
test_blueprint.configure_time_axis(3)
test_parser = FitsParser(src=[hdr1, hdr2, hdr3, hdr4, hdr5, hdr6, hdr7])
test_uri = 'ad:CFHT/1709071g.fits.gz'
update_blueprint(test_blueprint,
test_uri,
config={},
defaults={},
overrides={})
assert test_parser.blueprint._get('Observation.type') == \
(['OBSTYPE'], None), 'unmodified blueprint'
test_defaults = {
'CTYPE1': 'RA---TAN',
'CTYPE2': 'DEC--TAN',
'CTYPE3': 'TIME',
'CTYPE4': 'WAVE',
'CDELT4': '1.2',
'CRVAL4': '32'
}
update_blueprint(test_blueprint,
test_uri,
config={},
defaults=test_defaults,
overrides={})
assert test_blueprint._get('Chunk.position.axis.axis1.ctype') == \
(['CTYPE1'], 'RA---TAN'), 'default value assigned'
assert test_blueprint._get('Chunk.position.axis.axis2.ctype') == \
(['CTYPE2'], 'DEC--TAN'), 'default value assigned'
assert test_blueprint._get('Chunk.time.axis.axis.ctype') == \
(['CTYPE3'], 'TIME'), 'default value assigned, value all upper case'
# print(test_parser.blueprint)
test_defaults = {
'CTYPE1': 'RA--TAN',
'CTYPE2': 'DEC--TAN',
'CTYPE3': 'TIME',
'plane.dataProductType': 'image',
'provenance.producer': 'CFHT',
'provenance.project': 'STANDARD PIPELINE'
}
test_config = load_config(java_config_file)
test_overrides = load_config(override_file)
update_blueprint(test_blueprint, test_uri, test_config, test_defaults,
test_overrides)
assert test_blueprint._get('Plane.dataProductType') == \
'image', 'default value assigned to configuration'
assert test_blueprint._get('Plane.provenance.producer') == \
(['ORIGIN'], 'CFHT'), \
'default value assigned to configuration, all upper-case'
assert test_blueprint._get('Plane.provenance.project') == \
(['ADC_ARCH'], 'STANDARD PIPELINE'), \
'default value assigned to configuration, with white-space'
assert test_blueprint._get('Observation.type') == 'OBJECT', \
'default value over-ridden, value all upper case'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
0) == '210.551666667', 'override HDU 0'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val', 1) == \
'210.551666667', 'override HDU 1'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
2) == '210.508333333', 'override HDU 2'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
3) == '210.898333333', 'override HDU 3'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
4) == '210.942083333', 'override HDU 4'
assert test_blueprint._get(
'Chunk.position.axis.function.refCoord.coord1.val',
5) == '0.000000000', 'override HDU 5'
test_parser.blueprint = test_blueprint
assert test_parser._headers[0]['CRVAL1'] == 210.551666667, 'override HDU 0'
assert test_parser._headers[1]['CRVAL1'] == 210.551666667, 'override HDU 1'
assert test_parser._headers[2]['CRVAL1'] == 210.508333333, 'override HDU 2'
assert test_parser._headers[3]['CRVAL1'] == 210.898333333, 'override HDU 3'
assert test_parser._headers[4]['CRVAL1'] == 210.942083333, 'override HDU 4'
assert test_parser._headers[5]['CRVAL1'] == 0.000000000, 'override HDU 5'
assert test_parser._headers[0][
'CRVAL3'] == 56789.429806900000, 'override HDU 0'
# this will fail because of CompositeObservation.members errors
assert len(test_parser._errors) == 0, test_parser._errors
def test_augment_artifact_energy_from_blueprint():
test_blueprint = ObsBlueprint(energy_axis=1)
test_blueprint.set('Chunk.energyAxis', 1)
test_blueprint.set('Chunk.energy.specsys', 'LSRK')
test_blueprint.set('Chunk.energy.axis.axis.ctype', 'VRAD')
test_blueprint.set('Chunk.energy.axis.axis.cunit', 'm / s')
test_blueprint.set('Chunk.energy.axis.function.refCoord.pix', '145.0')
test_blueprint.set('Chunk.energy.axis.function.refCoord.val', '-60000.0')
test_blueprint.set('Chunk.energy.axis.function.delta', '-824.46002')
test_blueprint.set('Chunk.energy.axis.function.naxis', '1')
test_fitsparser = FitsParser(sample_file_4axes,
test_blueprint,
uri='ad:TEST/test_blueprint')
test_chunk = Chunk()
test_fitsparser._try_energy_with_blueprint(test_chunk, 0)
ex = _get_from_str_xml(EXPECTED_ENERGY_XML,
ObservationReader()._get_spectral_wcs, 'energy')
result = get_differences(ex, test_chunk.energy)
assert result is None
def test_has_chunk():
# the CFHT case
ob = ObsBlueprint()
ob.configure_position_axes((1, 2))
ob.set('Chunk', '{ignore}')
ob.set('Chunk.position.axis.axis1.ctype', 'RA---SIN', 1)
assert not ob.has_chunk(0)
assert ob.has_chunk(1)
# the OMM case
ob = ObsBlueprint()
ob.configure_position_axes((1, 2))
ob.set('Chunk', '{ignore}', 1)
assert ob.has_chunk(0)
assert not ob.has_chunk(1)
def test_load_from_file_configure():
ob = ObsBlueprint()
assert not ob._pos_axes_configed, \
'Failure to initialize configure_position_axes'
assert not ob._energy_axis_configed, \
'Failure to initialize configure_energy_axis'
ob.add_fits_attribute('Chunk.position.axis.axis1.ctype', 'CTYPE1')
ob.add_fits_attribute('Chunk.position.axis.axis2.ctype', 'CTYPE2')
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._pos_axes_configed, 'Failure to call configure_position_axes'
assert ob._energy_axis_configed, 'Failure to call configure_energy_axis'
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE3', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
ob = ObsBlueprint()
ob.add_fits_attribute('Chunk.position.axis.axis1.ctype', 'CTYPE3')
ob.add_fits_attribute('Chunk.position.axis.axis2.ctype', 'CTYPE4')
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._pos_axes_configed, 'Failure to call configure_position_axes'
assert ob._energy_axis_configed, 'Failure to call configure_energy_axis'
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE1', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
ob = ObsBlueprint()
ob.set('Chunk.energy.axis.axis.ctype', 'WAVE')
ob._guess_axis_info_from_plan()
assert ob._wcs_std['Chunk.energy.axis.axis.ctype'] == 'CTYPE3', \
ob._wcs_std['Chunk.energy.axis.axis.ctype']
