def test_set_process_timestamps(self): dataset = DataSet(data={'description': 'test dataset'}) time.sleep(3) update_dataset_process_end_ts(dataset.id) start_time, end_time = db_query( """ SELECT process_start_ts, process_end_ts FROM dataset WHERE id = %(id)s """, { "id": dataset.id }).fetchone() self.assertLess(start_time, end_time)
def test_frequency_difference(self): # Check that images which are at almost the same fall nicely into the # same band (unless they fall over a band boundary). See #4801. # Bands are 1 MHz wide and centred on the MHz. def get_band_for_image(image): # Returns the band number corresponding to a particular image. return tkp.db.execute( """ SELECT band FROM image WHERE image.id = %(id)s """, { "id": image.id }).fetchone()[0] data = copy(self.image_data) dataset1 = DataSet(data={'description': self._testMethodName}, database=self.database) # Example frequencies/bandwidths supplied in bug report. data['freq_eff'] = 124021911.62109375 data['freq_bw'] = 1757812.5 # image1 and image2 are exactly the same, so should be in the same # band. image1 = Image(dataset=dataset1, data=data) image2 = Image(dataset=dataset1, data=data) self.assertEqual(get_band_for_image(image1), get_band_for_image(image2)) # Another image at a frequency 1 MHz different should be in # a different band... data['freq_eff'] = data['freq_eff'] - 1e6 image3 = Image(dataset=dataset1, data=data) self.assertNotEqual(get_band_for_image(image1), get_band_for_image(image3)) # ...even if it has a huge bandwidth. data['freq_bw'] *= 100 image4 = Image(dataset=dataset1, data=data) self.assertNotEqual(get_band_for_image(image1), get_band_for_image(image4)) # Finally, this image should be in the same band, since it's at an only # slightly different frequency. data['freq_eff'] = 123924255.37109375 data['freq_bw'] = 1953125.0 image5 = Image(dataset=dataset1, data=data) self.assertEqual(get_band_for_image(image1), get_band_for_image(image5))
def test_update(self): image_data = db_subs.example_dbimage_data_dict() dataset1 = DataSet(data={'description': 'dataset with images'}, database=self.database) self.assertEqual(dataset1.images, set()) image1 = Image(dataset=dataset1, data=image_data) image2 = Image(dataset=dataset1, data=image_data) extractedsource_data = { 'ra': 123.123, 'decl': 23.23, 'ra_err': 21.1, 'decl_err': 21.09, 'ra_fit_err': 0.1, 'decl_fit_err': 0.1, 'uncertainty_ew': 0.1, 'uncertainty_ns': 0.1, 'zone': 1, 'x': 0.11, 'y': 0.22, 'z': 0.33, 'racosdecl': 0.44, 'det_sigma': 11.1, 'ew_sys_err': 20, 'ns_sys_err': 20, 'error_radius': 10.0 } source1 = ExtractedSource(image=image1, data=extractedsource_data) extractedsource_data['ra'] = 45.45 extractedsource_data['decl'] = 55.55 source2 = ExtractedSource(image=image1, data=extractedsource_data) self.assertEqual(len(image1.sources), 2) # Source #3 points to the same source as #2 source3 = ExtractedSource(id=source2.id, database=self.database) # Update source3 source3.update(decl=44.44) # But no change for #1 and #2 self.assertAlmostEqual(source1.decl, 23.23) self.assertAlmostEqual(source2.decl, 55.55) self.assertAlmostEqual(source3.decl, 44.44) source1.update() # nothing changes for #1 self.assertAlmostEqual(source1.decl, 23.23) self.assertAlmostEqual(source2.decl, 55.55) self.assertAlmostEqual(source3.decl, 44.44) # Now we make sure source #2 takes note of the change done through #3 source2.update() self.assertAlmostEqual(source1.decl, 23.23) self.assertAlmostEqual(source1.decl, 23.23) self.assertAlmostEqual(source2.decl, 44.44)
def test_update(self): """Update all or individual dataset columns""" dataset1 = DataSet(data={'description': 'dataset 1'}, ) self.assertEqual(dataset1.description, "dataset 1") dataset1.update(rerun=5, description="new dataset") self.database.cursor.execute( "SELECT rerun, description FROM dataset WHERE id=%s", (dataset1.id, )) results = self.database.cursor.fetchone() self.assertEqual(results[0], 5) self.assertEqual(results[1], "new dataset") self.assertEqual(dataset1.description, "new dataset") self.assertEqual(dataset1.rerun, 5) dataset1.update(process_end_ts=datetime.datetime(1970, 1, 1)) self.assertEqual(dataset1.process_end_ts, datetime.datetime(1970, 1, 1))
def test_create(self): dataset = DataSet(data={'description': 'dataset with images'}, database=self.database) # create 4 images, separated by one day each image = Image(dataset=dataset, data=db_subs.example_dbimage_data_dict()) extracted_source_data = dict(zone=13, ra=12.12, decl=13.13, ra_err=21.1, decl_err=21.09, ra_fit_err=1.12, decl_fit_err=1.23, uncertainty_ew=0.1, uncertainty_ns=0.1, ew_sys_err=20, ns_sys_err=20, error_radius=10.0, x=0.11, y=0.22, z=0.33, racosdecl=0.44, det_sigma=10.) src1 = ExtractedSource(data=extracted_source_data, image=image) src2 = ExtractedSource(data=extracted_source_data, image=image, database=self.database) self.assertNotEqual(src1.id, src2.id) extracted_source_data['image'] = image.id src3 = ExtractedSource(data=extracted_source_data, database=self.database) extracted_source_data['ra'] = 23.23 src4 = ExtractedSource(data=extracted_source_data, database=self.database, id=src1.id) self.assertEqual(src1.id, src4.id) self.assertAlmostEqual(src1.ra, src4.ra) del extracted_source_data['x'] self.assertRaisesRegexp(AttributeError, "missing required data key: x", ExtractedSource, data=extracted_source_data, database=self.database)
def test_frequency_range(self): """ Determine range of frequencies supported by DB schema. """ dataset = DataSet(data={'description': self._testMethodName}, database=self.database) data = copy(self.image_data) data['freq_eff'] = 1e6 # 1MHz data['freq_bw'] = 1e3 # 1KHz mhz_freq_image = Image(dataset=dataset, data=data) self.assertEqual(data['freq_eff'], get_freq_for_image(mhz_freq_image)) data['freq_eff'] = 100e9 # 100 GHz (e.g. CARMA) data['freq_bw'] = 5e9 # 5GHz ghz_freq_image = Image(dataset=dataset, data=data) self.assertEqual(data['freq_eff'], get_freq_for_image(ghz_freq_image)) data['freq_eff'] = 5e15 # 5 PHz (e.g. UV obs) data['freq_bw'] = 1e14 # 100 THz phz_freq_image = Image(dataset=dataset, data=data) self.assertEqual(data['freq_eff'], get_freq_for_image(phz_freq_image))
def test_infinite(self): # Check that database insertion doesn't choke on infinite errors. dataset = DataSet(data={'description': 'example dataset'}, database=self.database) image = Image(dataset=dataset, data=db_subs.example_dbimage_data_dict()) # Inserting a standard example extractedsource should be fine extracted_source = db_subs.example_extractedsource_tuple() image.insert_extracted_sources([extracted_source]) inserted = columns_from_table('extractedsource', where={'image': image.id}) self.assertEqual(len(inserted), 1) # But if the source has infinite errors we drop it and log a warning extracted_source = db_subs.example_extractedsource_tuple( error_radius=float('inf'), peak_err=float('inf'), flux_err=float('inf')) # We will add a handler to the root logger which catches all log # output in a buffer. iostream = BytesIO() hdlr = logging.StreamHandler(iostream) logging.getLogger().addHandler(hdlr) image.insert_extracted_sources([extracted_source]) logging.getLogger().removeHandler(hdlr) # We want to be sure that the error has been appropriately logged. self.assertIn("Dropped source fit with infinite flux errors", iostream.getvalue()) inserted = columns_from_table('extractedsource', where={'image': image.id}) self.assertEqual(len(inserted), 1)
def test_frequency_difference(self): # Check that images which are at almost the same fall nicely into the # same band (unless they fall over a band boundary). See #4801. # Bands are 1 MHz wide and centred on the MHz. data = copy(self.image_data) dataset1 = DataSet(data={'description': self._testMethodName}, database=self.database) # Example frequencies/bandwidths supplied in bug report. data['freq_eff'] = 124021911.62109375 data['freq_bw'] = 1757812.5 # image1 and image2 are exactly the same, so should be in the same # band. image1 = Image(dataset=dataset1, data=data) image2 = Image(dataset=dataset1, data=data) self.assertEqual(get_band_for_image(image1), get_band_for_image(image2)) # Another image at a frequency 10 MHz different should be in # a different band... data['freq_eff'] -= 1e7 image3 = Image(dataset=dataset1, data=data) self.assertNotEqual(get_band_for_image(image1), get_band_for_image(image3)) # but in the same if the bandwidths overlap data['freq_bw'] *= 100 image4 = Image(dataset=dataset1, data=data) self.assertEqual(get_band_for_image(image1), get_band_for_image(image4)) # Finally, this image should be in the same band, since it's at an only # slightly different frequency. data['freq_eff'] = 123924255.37109375 data['freq_bw'] = 1953125.0 image5 = Image(dataset=dataset1, data=data) self.assertEqual(get_band_for_image(image1), get_band_for_image(image5))
def setUp(self): self.database = tkp.db.Database() self.dataset = DataSet(data={'description': 'dataset with images'}, database=self.database)
def setUp(self): data = {'description': "monitoringlist:" + self._testMethodName} self.dataset = DataSet(data=data) self.im_params = db_subs.generate_timespaced_dbimages_data(n_images=3)
def test_insert(self): dataset1 = DataSet(data=self.description) monitor_positions = [(5., 5), (123, 85.)] dbgen.insert_monitor_positions(dataset1.id, monitor_positions)
def setUp(self): self.dataset = DataSet( data={'description': "Src. assoc:" + self._testMethodName}) self.im_params = db_subs.generate_timespaced_dbimages_data(n_images=8) self.db_imgs = []
def test_m2m_nullDetection(self): """ This tests that two sources (close-by to be associated if they were detected at different timesteps) which are not seen in the next image and thus have forced fits, will have separate light curves. The postions are from the previous test. """ data = {'description': "null detection:" + self._testMethodName} dataset = DataSet(data=data) # Three timesteps, just 1 band -> 3 images. taustart_tss = [ datetime.datetime(2013, 8, 1), datetime.datetime(2013, 9, 1), datetime.datetime(2013, 10, 1) ] freq_effs = [124] freq_effs = [f * 1e6 for f in freq_effs] im_params = db_subs.generate_timespaced_dbimages_data( len(freq_effs) * len(taustart_tss)) timestamps = itertools.repeat(taustart_tss, len(freq_effs)) for im, freq, ts in zip( im_params, itertools.cycle(freq_effs), itertools.chain.from_iterable(zip(*timestamps))): im['freq_eff'] = freq im['taustart_ts'] = ts images = [] for im in im_params: image = tkp.db.Image(dataset=dataset, data=im) images.append(image) # Arbitrary parameters, except that they fall inside our image # and close together (see previous test) src0 = db_subs.example_extractedsource_tuple(ra=122.985, dec=10.5) src1 = db_subs.example_extractedsource_tuple(ra=123.015, dec=10.5) # Group images in blocks of 4, corresponding to all frequency bands at # a given timestep. for images in zip(*(iter(images), ) * len(freq_effs)): for image in images: # The sources are only seen at timestep 0 if (image.taustart_ts == taustart_tss[0]): dbgen.insert_extracted_sources(image.id, [src0, src1], 'blind') else: pass for image in images: dbass.associate_extracted_sources(image.id, deRuiter_r=5.68, new_source_sigma_margin=3) nd_ids_pos = dbnd.get_nulldetections(image.id) # The null_detections are the positional inputs for the forced # fits, which on their turn return additional parameters, # e.g. from src0, src1 if image.taustart_ts == taustart_tss[0]: # There are no null detections at the first timestep self.assertEqual(len(nd_ids_pos), 0) elif image.taustart_ts == taustart_tss[1]: # src0 & src1 are null detections at the second timestep self.assertEqual(len(nd_ids_pos), 2) dbgen.insert_extracted_sources( image.id, [src0, src1], 'ff_nd', ff_runcat_ids=[ids for ids, ra, decl in nd_ids_pos]) else: # All other images have two null detections. self.assertEqual(len(nd_ids_pos), 2) dbgen.insert_extracted_sources( image.id, [src0, src1], 'ff_nd', ff_runcat_ids=[ids for ids, ra, decl in nd_ids_pos]) # And here we have to associate the null detections with the # runcat sources... dbnd.associate_nd(image.id) query = """\ SELECT id ,datapoints FROM runningcatalog r WHERE dataset = %(dataset_id)s ORDER BY datapoints """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have two runningcatalog sources, with a datapoint for # every image in which the sources were seen. self.assertEqual(len(result), 2) query = """\ SELECT r.id ,rf.band ,rf.f_datapoints FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset_id)s AND rf.runcat = r.id ORDER BY r.id ,rf.band """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have two runningcatalog_flux entries, # one for every source in the band, i.e. 2 x 1. self.assertEqual(len(result), 2) # Source 0: inserted into timestep 0. # Force-fits in images at next timesteps, # so 1+2 for band 0. self.assertEqual(result[0][2], 3) # Source 1: inserted into timestep 0 # Force-fits in images at next timesteps. # so 1+2 for bands 0 self.assertEqual(result[1][2], 3) #self.assertEqual(result[2][2], 2) #self.assertEqual(result[3][2], 2) # We should also have two lightcurves for both sources, # where source 1 has 3 datapoints in band0 (t1,t2,t3). # Source 2 also has 3 datapoints for band0 (t1,t2,t3). query = """\ SELECT a.runcat ,a.xtrsrc ,a.type ,i.band ,i.taustart_ts FROM assocxtrsource a ,extractedsource x ,image i WHERE a.xtrsrc = x.id AND x.image = i.id AND i.dataset = %(dataset_id)s ORDER BY a.runcat ,i.band ,i.taustart_ts """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # 3 + 3 entries for source 0 and 1 resp. self.assertEqual(len(result), 6) # The individual light-curve datapoints # Source1: new at t1, band0 self.assertEqual(result[0][2], 4) self.assertEqual(result[0][4], taustart_tss[0]) # Source1: Forced fit at t2, same band self.assertEqual(result[1][2], 7) self.assertEqual(result[1][3], result[0][3]) self.assertEqual(result[1][4], taustart_tss[1]) # Source1: Forced fit at t3, same band self.assertEqual(result[2][2], 7) self.assertEqual(result[2][3], result[1][3]) self.assertEqual(result[2][4], taustart_tss[2]) # Source2: new at t1, band0 self.assertEqual(result[3][2], 4) self.assertEqual(result[3][3], result[1][3]) self.assertEqual(result[3][4], taustart_tss[0]) # Source2: Forced fit at t2, band0 self.assertEqual(result[4][2], 7) self.assertEqual(result[4][3], result[3][3]) self.assertEqual(result[4][4], taustart_tss[1]) # Source2: Forced fit at t3, band0 self.assertEqual(result[5][2], 7) self.assertEqual(result[5][3], result[4][3]) self.assertEqual(result[5][4], taustart_tss[2])
def test_nullDetection(self): data = {'description': "null detection:" + self._testMethodName} dataset = DataSet(data=data) # Three timesteps, each with 4 bands -> 12 images. taustart_tss = [ datetime.datetime(2013, 8, 1), datetime.datetime(2013, 9, 1), datetime.datetime(2013, 10, 1) ] freq_effs = [124, 149, 156, 185] freq_effs = [f * 1e6 for f in freq_effs] im_params = db_subs.generate_timespaced_dbimages_data( len(freq_effs) * len(taustart_tss)) timestamps = itertools.repeat(taustart_tss, len(freq_effs)) for im, freq, ts in zip( im_params, itertools.cycle(freq_effs), itertools.chain.from_iterable(zip(*timestamps))): im['freq_eff'] = freq im['taustart_ts'] = ts images = [] for im in im_params: image = tkp.db.Image(dataset=dataset, data=im) images.append(image) # Arbitrary parameters, except that they fall inside our image. src0 = db_subs.example_extractedsource_tuple(ra=122.5, dec=9.5) src1 = db_subs.example_extractedsource_tuple(ra=123.5, dec=10.5) # Group images in blocks of 4, corresponding to all frequency bands at # a given timestep. for images in zip(*(iter(images), ) * len(freq_effs)): for image in images: # The first source is only seen at timestep 0, band 0. # The second source is only seen at timestep 1, band 3. if (image.taustart_ts == taustart_tss[0] and image.freq_eff == freq_effs[0]): dbgen.insert_extracted_sources(image.id, [src0], 'blind') elif (image.taustart_ts == taustart_tss[1] and image.freq_eff == freq_effs[3]): dbgen.insert_extracted_sources(image.id, [src1], 'blind') else: pass for image in images: dbass.associate_extracted_sources(image.id, deRuiter_r=5.68, new_source_sigma_margin=3) nd_ids_pos = dbnd.get_nulldetections(image.id) # The null_detections are the positional inputs for the forced # fits, which on their turn return additional parameters, # e.g. from src0, src1 if image.taustart_ts == taustart_tss[0]: # There are no null detections at the first timestep self.assertEqual(len(nd_ids_pos), 0) elif image.taustart_ts == taustart_tss[1]: # src0 is a null detection at the second timestep self.assertEqual(len(nd_ids_pos), 1) dbgen.insert_extracted_sources( image.id, [src0], 'ff_nd', ff_runcat_ids=[ids for ids, ra, decl in nd_ids_pos]) else: # All other images have two null detections. self.assertEqual(len(nd_ids_pos), 2) dbgen.insert_extracted_sources( image.id, [src0, src1], 'ff_nd', ff_runcat_ids=[ids for ids, ra, decl in nd_ids_pos]) # And here we have to associate the null detections with the # runcat sources... dbnd.associate_nd(image.id) query = """\ SELECT id ,datapoints FROM runningcatalog r WHERE dataset = %(dataset_id)s ORDER BY datapoints """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have two runningcatalog sources, with a datapoint for # every image in which the sources were seen. self.assertEqual(len(result), 2) query = """\ SELECT r.id ,rf.band ,rf.f_datapoints FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset_id)s AND rf.runcat = r.id ORDER BY r.id ,rf.band """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have eight runningcatalog_flux entries, # one for every source in every band, i.e. 2 x 4. # The number of flux datapoints differ per source, though self.assertEqual(len(result), 8) # Source 1: inserted into timestep 0, band 0. # Force-fits in band 0 images at next timesteps, # so 1+2 for band 0. self.assertEqual(result[0][2], 3) # Source 1: inserted into timestep 0, band 0. # Force-fits in bands 1,2,3 images at next timesteps. # so 0+2 for bands 1,2,3. self.assertEqual(result[1][2], 2) self.assertEqual(result[2][2], 2) self.assertEqual(result[3][2], 2) # Source 2: inserted into timestep 1, band 3. # Force-fits in band 0,1,2 images at next timestep, # so 1 for band 0,1,2 self.assertEqual(result[4][2], 1) self.assertEqual(result[5][2], 1) self.assertEqual(result[6][2], 1) # Source 2: inserted into timestep 1, band 3. # Force-fit in band 3 image at next timestep, # so 1+1 for band 3 self.assertEqual(result[7][2], 2) # We should also have two lightcurves for both sources, # where source 1 has 3 datapoints in band0 (t1,t2,t3) # and 2 datapoints for the other three bands (t2,t3). # Source 2 has two datapoints for band3 (t2,t3) and # one for the other three bands (t3). query = """\ SELECT a.runcat ,a.xtrsrc ,a.type ,i.band ,i.taustart_ts FROM assocxtrsource a ,extractedsource x ,image i WHERE a.xtrsrc = x.id AND x.image = i.id AND i.dataset = %(dataset_id)s ORDER BY a.runcat ,i.band ,i.taustart_ts """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # 9 + 5 entries for source 1 and 2 resp. self.assertEqual(len(result), 14) # The individual light-curve datapoints # Source1: new at t1, band0 self.assertEqual(result[0][2], 4) self.assertEqual(result[0][4], taustart_tss[0]) # Source1: Forced fit at t2, same band self.assertEqual(result[1][2], 7) self.assertEqual(result[1][3], result[0][3]) self.assertEqual(result[1][4], taustart_tss[1]) # Source1: Forced fit at t3, same band self.assertEqual(result[2][2], 7) self.assertEqual(result[2][3], result[1][3]) self.assertEqual(result[2][4], taustart_tss[2]) # Source1: Forced fit at t2, band1 self.assertEqual(result[3][2], 7) self.assertTrue(result[3][3] > result[2][3]) self.assertEqual(result[3][4], taustart_tss[1]) # Source1: Forced fit at t3, band1 self.assertEqual(result[4][2], 7) self.assertEqual(result[4][3], result[3][3]) self.assertEqual(result[4][4], taustart_tss[2]) # Source1: Forced fit at t2, band2 self.assertEqual(result[5][2], 7) self.assertTrue(result[5][3] > result[4][3]) self.assertEqual(result[5][4], taustart_tss[1]) # Source1: Forced fit at t3, band2 self.assertEqual(result[6][2], 7) self.assertEqual(result[6][3], result[5][3]) self.assertEqual(result[6][4], taustart_tss[2]) # Source1: Forced fit at t2, band3 self.assertEqual(result[7][2], 7) self.assertTrue(result[7][3] > result[6][3]) self.assertEqual(result[7][4], taustart_tss[1]) # Source1: Forced fit at t3, band3 self.assertEqual(result[8][2], 7) self.assertEqual(result[8][3], result[7][3]) self.assertEqual(result[8][4], taustart_tss[2]) # Source2: Forced fit at t3, band0 self.assertEqual(result[9][2], 7) self.assertEqual(result[9][3], result[0][3]) self.assertEqual(result[9][4], taustart_tss[2]) # Source2: Forced fit at t3, band1 self.assertEqual(result[10][2], 7) self.assertTrue(result[10][3] > result[9][3]) self.assertEqual(result[10][4], taustart_tss[2]) # Source2: Forced fit at t3, band2 self.assertEqual(result[11][2], 7) self.assertTrue(result[11][3] > result[10][3]) self.assertEqual(result[11][4], taustart_tss[2]) # Source2: new at t2, band3 self.assertEqual(result[12][2], 4) self.assertTrue(result[12][3] > result[11][3]) self.assertEqual(result[12][4], taustart_tss[1]) # Source2: Forced fit at t3, band3 self.assertEqual(result[13][2], 7) self.assertEqual(result[13][3], result[12][3]) self.assertEqual(result[13][4], taustart_tss[2])
def test_1to1_nullDetection(self): """ This tests that the two sources are associated if they were detected at different timesteps. The positions are used in the next test as well. """ data = {'description': "null detection:" + self._testMethodName} dataset = DataSet(data=data) # Two timesteps, just 1 band -> 2 images. taustart_tss = [ datetime.datetime(2013, 8, 1), datetime.datetime(2013, 9, 1) ] freq_effs = [124] freq_effs = [f * 1e6 for f in freq_effs] im_params = db_subs.generate_timespaced_dbimages_data( len(freq_effs) * len(taustart_tss)) timestamps = itertools.repeat(taustart_tss, len(freq_effs)) for im, freq, ts in zip( im_params, itertools.cycle(freq_effs), itertools.chain.from_iterable(zip(*timestamps))): im['freq_eff'] = freq im['taustart_ts'] = ts images = [] for im in im_params: image = tkp.db.Image(dataset=dataset, data=im) images.append(image) # Arbitrary parameters, except that they fall inside our image # and close together (see next test) src0 = db_subs.example_extractedsource_tuple(ra=122.985, dec=10.5) src1 = db_subs.example_extractedsource_tuple(ra=123.015, dec=10.5) # Group images in blocks of 4, corresponding to all frequency bands at # a given timestep. for images in zip(*(iter(images), ) * len(freq_effs)): for image in images: # The sources are only seen at timestep 0 if (image.taustart_ts == taustart_tss[0]): dbgen.insert_extracted_sources(image.id, [src0], 'blind') elif (image.taustart_ts == taustart_tss[1]): dbgen.insert_extracted_sources(image.id, [src1], 'blind') else: pass for image in images: dbass.associate_extracted_sources(image.id, deRuiter_r=5.68, new_source_sigma_margin=3) query = """\ SELECT id ,datapoints FROM runningcatalog r WHERE dataset = %(dataset_id)s ORDER BY datapoints """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have one runningcatalog sources, with two datapoints # for the images in which the sources were seen. self.assertEqual(len(result), 1) self.assertEqual(result[0][1], 2) query = """\ SELECT r.id ,rf.band ,rf.f_datapoints FROM runningcatalog r ,runningcatalog_flux rf WHERE r.dataset = %(dataset_id)s AND rf.runcat = r.id ORDER BY r.id ,rf.band """ cursor = tkp.db.execute(query, {'dataset_id': dataset.id}) result = cursor.fetchall() # We should have one runningcatalog_flux entry, # where the source has two flux datapoints self.assertEqual(len(result), 1) self.assertEqual(result[0][2], 2)