docs: def parse(self, ssos_result_filename_or_lines, mpc_observations=None):
          """
          given the result table create 'source' objects.
  
          :param ssos_result_filename_or_lines:
          :param mpc_observations: a list of mpc.Observation objects used to retrieve the SSOS observations
          """
          table_reader = ascii.get_reader(Reader=ascii.Basic)
          table_reader.inconsistent_handler = self._skip_missing_data
          table_reader.header.splitter.delimiter = '\t'
          table_reader.data.splitter.delimiter = '\t'
          ssos_table = table_reader.read(ssos_result_filename_or_lines)
  
          dbimage_list = storage.list_dbimages(dbimages=storage.DBIMAGES)
          logger.debug("Comparing to {} observations in dbimages: {}".format(len(dbimage_list), storage.DBIMAGES))
          sources = []
          observations = []
          source_readings = []
  
          if mpc_observations is not None and isinstance(mpc_observations[0], mpc.Observation):
              orbit = Orbfit(mpc_observations)
          else:
              from mp_ephem import horizons
              start_time = Time(min(ssos_table['MJD']), format='mjd')
              stop_time = Time(max(ssos_table['MJD']), format='mjd')
              step_size = 5.0 * units.hour
              orbit = horizons.Body(self.provisional_name, start_time, stop_time, step_size)
  
          warnings.filterwarnings('ignore')
          logger.info("Loading {} observations\n".format(len(ssos_table)))
          expnums_examined = []
          for row in ssos_table:
              # Trim down to OSSOS-specific images
  
              logger.debug("Checking row: {}".format(row))
              if (row['Filter'] not in parameters.OSSOS_FILTERS) or row['Image_target'].startswith('WP'):
                  logger.debug("Failed filter / target name check")
                  continue
  
              # check if a dbimages object exists
              # For CFHT/MegaCam strip off the trailing character to get the exposure number.
              ftype = row['Image'][-1]
              expnum = row['Image'][:-1]
              if str(expnum) not in dbimage_list:
                  logger.debug("Expnum: {} Failed dbimage list check".format(expnum))
                  continue
              logger.debug("Expnum: {} Passed dbimage list check".format(expnum))
              # The file extension is the ccd number + 1 , or the first extension.
              ccd = int(row['Ext'])-1
              if 39 < ccd < 0 or ccd < 0:
                  ccd = None
              x = row['X'] * units.pix
              y = row['Y'] * units.pix
              ra = row['Object_RA'] * units.degree
              dec = row['Object_Dec'] * units.degree
              ssois_coordinate = SkyCoord(ra, dec)
              mjd = row['MJD'] * units.day
  
              # if not 0 < x.value < 2060 or not 0 < y.value < 4700:
              #    continue
  
              obs_date = Time(mjd, format='mjd', scale='utc')
              logger.info("Calling predict")
              orbit.predict(obs_date)
              logger.info("Done calling predict")
              if orbit.dra > 4 * units.arcminute or orbit.ddec > 4.0 * units.arcminute:
                  print "Skipping entry as orbit uncertainty at date {} is large.".format(obs_date)
                  continue
              if expnum in expnums_examined:
                  logger.debug("Already checked this exposure.")
                  continue
              expnums_examined.append(expnum)
  
              logger.debug(("SSOIS Prediction: exposure:{} ext:{} "
                            "ra:{} dec:{} x:{} y:{}").format(expnum, ccd, ra, dec, x, y))
  
              logger.debug(("Orbfit Prediction: "
                            "ra:{} dec:{} ").format(orbit.coordinate.ra.to(units.degree),
                                                    orbit.coordinate.dec.to(units.degree)))
              logger.info("Building Observation")
              observation = SSOSParser.build_source_reading(expnum, ccd, ftype=ftype)
              observation.mjd = mjd
              from_input_file = observation.rawname in self.input_rawnames
              # compare to input observation list.
              previous = False
              mpc_observation = None
              if from_input_file:
                  for mpc_observation in mpc_observations:
                      try:
                          if mpc_observation.comment.frame.strip() == observation.rawname:
                              # only skip previous obseravtions if not discovery.
                              previous = not mpc_observation.discovery
                              break
                      except Exception as e:
                          logger.debug(str(e))
                          pass
                      mpc_observation = None
  
              # skip previously measured observations if requested.
              if self.skip_previous and ( previous or observation.rawname in self.null_observations):
                  continue
  
              logger.info('built observation {}'.format(observation))
              observations.append(observation)
              null_observation = observation.rawname in self.null_observations
  
              ddec = orbit.ddec + abs(orbit.coordinate.dec - ssois_coordinate.dec)
              dra = orbit.dra + abs(orbit.coordinate.ra - ssois_coordinate.ra)
  
              logger.info(" Building SourceReading .... \n")
              source_reading = astrom.SourceReading(x=x, y=y, x0=x, y0=y,
                                                    ra=orbit.coordinate.ra.to(units.degree).value,
                                                    dec=orbit.coordinate.dec.to(units.degree).value,
                                                    xref=x, yref=y, obs=observation,
                                                    ssos=True, from_input_file=from_input_file,
                                                    dx=dra, dy=ddec, pa=orbit.pa,
                                                    null_observation=null_observation)
              source_reading.mpc_observation = mpc_observation
              source_readings.append(source_reading)
              logger.info("Source Reading Built")
  
          # build our array of SourceReading objects
          sources.append(source_readings)
  
          warnings.filterwarnings('once')
  
          return SSOSData(observations, sources, self.provisional_name)