示例#1
0
def query_segments_db(db_location, gps_start, gps_end, spec):
    """
	Query db_location to get segments between (gps_start, gps_end), with definer spec.
	"""
    engine = LdbdQueryEngine(segmentdb_utils.setup_database(db_location))
    ifo, definer, version = spec.split(":")
    definer_args = [[ifo, definer, int(version), gps_start, gps_end, 0, 0]]
    result = segmentdb_utils.query_segments(engine, "segment", definer_args)
    return segmentlist(result[0])
示例#2
0
def query_segments_db(db_location, gps_start, gps_end, spec):
    """
	Query db_location to get segments between (gps_start, gps_end), with definer spec.
	"""
    engine = LdbdQueryEngine(segmentdb_utils.setup_database(db_location))
    ifo, definer, version = spec.split(":")
    definer_args = [[ifo, definer, int(version), gps_start, gps_end, 0, 0]]
    result = segmentdb_utils.query_segments(engine, "segment", definer_args)
    return segmentlist(result[0])
def get_manually(gps_start_time, gps_end_time):
    db_location = os.environ['S6_SEGMENT_SERVER']
    segment_connection = segmentdb_utils.setup_database(db_location)
    engine = query_engine.LdbdQueryEngine(segment_connection)

    # 1. Get v1 science segments

    sql = "SELECT segment.start_time, segment.end_time "
    sql += "FROM segment_definer, segment "
    sql += "WHERE segment.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 1 "
    sql += "AND NOT (%s > segment.end_time OR segment.start_time > %s)" % (
        gps_start_time, gps_end_time)

    v1_science_segments = segmentlist(
        [segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    # 2. Get v2 science summaries

    sql = "SELECT segment_summary.start_time, segment_summary.end_time "
    sql += "FROM segment_definer, segment_summary "
    sql += "WHERE segment_summary.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment_summary.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 2 "
    sql += "AND NOT (%s > segment_summary.end_time OR segment_summary.start_time > %s)" % (
        gps_start_time, gps_end_time)

    v2_science_summaries = segmentlist(
        [segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    # 1. Get v2 science segments

    sql = "SELECT segment.start_time, segment.end_time "
    sql += "FROM segment_definer, segment "
    sql += "WHERE segment.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 2 "
    sql += "AND NOT (%s > segment.end_time OR segment.start_time > %s)" % (
        gps_start_time, gps_end_time)

    v2_science_segments = segmentlist(
        [segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    result = (v1_science_segments - v2_science_summaries) + v2_science_segments

    result.coalesce()

    result &= segmentlist([segment(gps_start_time, gps_end_time)])

    return result
示例#4
0
def get_manually(gps_start_time, gps_end_time):
    db_location = os.environ["S6_SEGMENT_SERVER"]
    segment_connection = segmentdb_utils.setup_database(db_location)
    engine = query_engine.LdbdQueryEngine(segment_connection)

    # 1. Get v1 science segments

    sql = "SELECT segment.start_time, segment.end_time "
    sql += "FROM segment_definer, segment "
    sql += "WHERE segment.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 1 "
    sql += "AND NOT (%s > segment.end_time OR segment.start_time > %s)" % (gps_start_time, gps_end_time)

    v1_science_segments = segmentlist([segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    # 2. Get v2 science summaries

    sql = "SELECT segment_summary.start_time, segment_summary.end_time "
    sql += "FROM segment_definer, segment_summary "
    sql += "WHERE segment_summary.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment_summary.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 2 "
    sql += "AND NOT (%s > segment_summary.end_time OR segment_summary.start_time > %s)" % (gps_start_time, gps_end_time)

    v2_science_summaries = segmentlist([segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    # 1. Get v2 science segments

    sql = "SELECT segment.start_time, segment.end_time "
    sql += "FROM segment_definer, segment "
    sql += "WHERE segment.segment_def_id = segment_definer.segment_def_id "
    sql += "AND   segment_definer.ifos = 'H1' "
    sql += "AND   segment.segment_def_cdb = segment_definer.creator_db "
    sql += "AND   segment_definer.name = 'DMT-SCIENCE' "
    sql += "AND   segment_definer.version = 2 "
    sql += "AND NOT (%s > segment.end_time OR segment.start_time > %s)" % (gps_start_time, gps_end_time)

    v2_science_segments = segmentlist([segment(row[0], row[1]) for row in engine.query(sql)]).coalesce()

    result = (v1_science_segments - v2_science_summaries) + v2_science_segments

    result.coalesce()

    result &= segmentlist([segment(gps_start_time, gps_end_time)])

    return result
示例#5
0
    def query_segdb(cls, flags, *args, **kwargs):
        """Query the inital LIGO segment database for a list of flags.

        Parameters
        ----------
        flags : `iterable`
            A list of flag names for which to query.
        *args
            Either, two `float`-like numbers indicating the
            GPS [start, stop) interval, or a `SegmentList`
            defining a number of summary segments.
        url : `str`, optional, default: ``'https://segments.ligo.org'``
            URL of the segment database.

        Returns
        -------
        flagdict : `DataQualityDict`
            An ordered `DataQualityDict` of (name, `DataQualityFlag`)
            pairs.
        """
        # given segmentlist
        if len(args) == 1 and isinstance(args[0], SegmentList):
            qsegs = args[0]
        elif len(args) == 1 and len(args[0]) == 2:
            qsegs = SegmentList(Segment(to_gps(args[0][0]),
                                        to_gps(args[0][1])))
        elif len(args) == 2:
            qsegs = SegmentList([Segment(to_gps(args[0]), to_gps(args[1]))])
        else:
            raise ValueError("DataQualityDict.query_segdb must be called with "
                             "a list of flag names, and either GPS start and "
                             "stop times, or a SegmentList of query segments")
        url = kwargs.pop('url', 'https://segments.ligo.org')
        if kwargs.pop('on_error', None) is not None:
            warnings.warn("DataQualityDict.query_segdb doesn't accept the "
                          "on_error keyword argument")
        if kwargs.keys():
            raise TypeError("DataQualityDict.query_segdb has no keyword "
                            "argument '%s'" % list(kwargs.keys()[0]))

        # process query
        from glue.segmentdb import (segmentdb_utils as segdb_utils,
                                    query_engine as segdb_engine)
        connection = segdb_utils.setup_database(url)
        engine = segdb_engine.LdbdQueryEngine(connection)
        segdefs = []
        for flag in flags:
            dqflag = DataQualityFlag(name=flag)
            ifo = dqflag.ifo
            name = dqflag.tag
            if dqflag.version is None:
                vers = '*'
            else:
                vers = dqflag.version
            for gpsstart, gpsend in qsegs:
                if float(gpsend) == +inf:
                    gpsend = to_gps('now').seconds
                gpsstart = float(gpsstart)
                if not gpsstart.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                gpsend = float(gpsend)
                if not gpsend.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                segdefs += segdb_utils.expand_version_number(
                    engine, (ifo, name, vers, gpsstart, gpsend, 0, 0))
        segs = segdb_utils.query_segments(engine, 'segment', segdefs)
        segsum = segdb_utils.query_segments(engine, 'segment_summary', segdefs)
        # build output
        out = cls()
        for definition, segments, summary in zip(segdefs, segs, segsum):
            # parse flag name
            flag = ':'.join(map(str, definition[:3]))
            name = flag.rsplit(':', 1)[0]
            # if versionless
            if flag.endswith('*'):
                flag = name
                key = name
            # if asked for versionless, but returned a version
            elif flag not in flags and name in flags:
                key = name
            # other
            else:
                key = flag
            # define flag
            if key not in out:
                out[key] = DataQualityFlag(name=flag)
            # add segments
            out[key].known.extend(summary)
            out[key].active.extend(segments)
        return out
示例#6
0
def dump_flags(ifos=None, segment_url=None, match=None, unmatch=None,\
               latest=False):

  """
    Returns the list of all flags defined in the database.

    Keyword rguments:
      ifo : [ str | list ]
        list of ifos to query, or str for single ifo
      segment_url : str 
        url of segment database, defaults to contents of S6_SEGMENT_SERVER
        environment variable
      match : [ str | regular pattern ]
        regular expression to search against returned flag names, e.g, 'UPV'
      unmatch : [ str | regular pattern ]
        regular expression to negatively search against returned flag names
  """

  if isinstance(ifos, str):
    ifos = [ifos]

  # get url
  if not segment_url:
    segment_url = os.getenv('S6_SEGMENT_SERVER')

  # open connection to LDBD(W)Server
  myClient = segmentdb_utils.setup_database(segment_url)

  reply = StringIO(myClient.query(squery))
  xmldoc, digest = utils.load_fileobj(reply)
  seg_def_table = table.get_table(xmldoc, lsctables.SegmentDefTable.tableName)

  # sort table by ifo, name and version
  seg_def_table.sort(key=lambda flag: (flag.ifos[0], flag.name, \
                                       flag.version), reverse=True)

  flags = lsctables.New(type(seg_def_table))

  for row in seg_def_table:

    # test re match
    if match and not re.search(match, row.name):  continue

    # test re unmatch
    if unmatch and re.search(unmatch, row.name):  continue

    # only append latest versions of multiple flags
    flatest=True
    if latest:
      # get all flags with same ifo and name
      vflags = [f for f in flags if row.name==f.name and\
                row.get_ifos()==f.get_ifos()]
      # if later version in list, move on
      for f in vflags:
        if f.version>=row.version:
          flatest=False
          break
    if not flatest:
      continue

    # append those flags matching ifos requirement
    for ifo in ifos:
      if ifo in row.get_ifos():
        flags.append(row)
        break

  return flags
示例#7
0
def grab_segments(start, end, flag,\
                  segment_url='https://segdb.ligo.caltech.edu',\
                  segment_summary=False):

  """
    Returns a segmentlist containing the segments during which the given flag
    was active in the given period.

    Arguments:

      start : int
        GPS start time
      end : int
        GPS end time
      flag : string
        'IFO:NAME:VERSION' format string

    Keyword arguments:

      segment_url : string
        url of segment database to query, default https://segdb.ligo.caltech.edu
      segment_summary : [ True | False ]
        also return the glue.segments.segmentlist defining the valid span of the
        returned segments
  """

  # set times
  start = int(math.floor(start))
  end   = int(math.ceil(end))

  # set query engine
  connection        = segmentdb_utils.setup_database(segment_url)
  engine            = query_engine.LdbdQueryEngine(connection)

  # format flag name
  if isinstance(flag, basestring):
    flags = flag.split(',')
  else:
    flags = flag

  segdefs = []
  for f in flags:
    spec = f.split(':')
    if len(spec) < 2 or len(spec) > 3:
      raise AttributeError, "Included segements must be of the form "+\
                            "ifo:name:version or ifo:name:*"

    ifo  = spec[0]
    name = spec[1]

    if len(spec) is 3 and spec[2] is not '*':
      version = int(spec[2])
      if version < 1:
        raise AttributeError, "Segment version numbers must be greater than zero"
    else:
      version = '*'

    # expand segment definer
    segdefs += segmentdb_utils.expand_version_number(engine, (ifo, name, version, \
                                                            start, end, 0, 0))

  # query database and return
  segs = segmentdb_utils.query_segments(engine, 'segment', segdefs)
  segs = [s.coalesce() for s in segs]
  if segment_summary:
    segsums = segmentdb_utils.query_segments(engine, 'segment_summary', segdefs)
    #segsums = reduce(operator.or_, segsums).coalesce()
    segsums = [s.coalesce() for s in segsums]
    segsummap = [segments.segmentlist() for f in flags]
    for segdef,segsum in zip(segdefs, segsums):
      try:
        fidx = flags.index(':'.join(map(str, segdef[:3])))
      except ValueError:
        fidx = flags.index(':'.join(segdef[:2]))
      segsummap[fidx].extend(segsum)
    if flag == flags[0]:
      return segs[0],segsummap[0]
    else:
      return segs,segsummap
  if flag == flags[0]:
    return segs[0]
  else:
    return segs
示例#8
0
文件: flag.py 项目: mcoughlin/gwpy
    def query(cls, flags, *args, **kwargs):
        """Query the segment database URL as given for the listed
        `DataQualityFlag` names

        Parameters
        ----------
        flag : str
            The name of the flag for which to query
        *args
            Either, two `float`-like numbers indicating the
            GPS [start, stop) interval, or a
            :class:`~gwpy.segments.segments.SegmentList`
            defining a number of summary segments
        url : `str`, optional, default: ``'https://segdb.ligo.caltech.edu'``
            URL of the segment database, defaults to segdb.ligo.caltech.edu

        Returns
        -------
        flag : `DataQualityFlag`
            A new `DataQualityFlag`, with the `valid` and `active` lists
            filled appropriately.
        """
        # parse arguments
        if len(args) == 1:
            qsegs = args[0]
        elif len(args) == 2:
            qsegs = [args]
        else:
            raise ValueError("DataQualityDict.query must be called with a "
                             "flag name, and either GPS start and stop times, "
                             "or a SegmentList of query segments")
        url = kwargs.pop('url', 'https://segdb.ligo.caltech.edu')
        if kwargs.keys():
            TypeError("DataQualityDict.query has no keyword argument '%s'"
                      % kwargs.keys()[0])
        # parse flags
        if isinstance(flags, basestring):
            flags = flags.split(',')
        else:
            flags = flags
        # process query
        from glue.segmentdb import (segmentdb_utils as segdb_utils,
                                    query_engine as segdb_engine)
        connection = segdb_utils.setup_database(url)
        engine = segdb_engine.LdbdQueryEngine(connection)
        segdefs = []
        for flag in flags:
            ifo, name, version = parse_flag_name(flag)
            if not version:
                version = '*'
            for gpsstart, gpsend in qsegs:
                gpsstart = int(float(gpsstart))
                gpsend = int(ceil(float(gpsend)))
                segdefs += segdb_utils.expand_version_number(
                               engine, (ifo, name, version,
                                        gpsstart, gpsend, 0, 0))
        segs = segdb_utils.query_segments(engine, 'segment', segdefs)
        segsum = segdb_utils.query_segments(engine, 'segment_summary', segdefs)
        segs = [s.coalesce() for s in segs]
        segsum = [s.coalesce() for s in segsum]
        # build output
        out = cls()
        for definition, segments, summary in zip(segdefs, segs, segsum):
            # parse flag name
            flag = ':'.join(map(str, definition[:3]))
            if flag.endswith('*'):
                flag = flag.rsplit(':', 1)[0]
            # define flag
            if not flag in out:
                out[flag] = DataQualityFlag(name=flag)
            # add segments
            out[flag].valid.extend(summary)
            out[flag].active.extend(segments)
        return out
示例#9
0
文件: flag.py 项目: mythkina/gwpy
    def query_segdb(cls, flags, *args, **kwargs):
        """Query the inital LIGO segment database for a list of flags.

        Parameters
        ----------
        flags : `iterable`
            A list of flag names for which to query.
        *args
            Either, two `float`-like numbers indicating the
            GPS [start, stop) interval, or a `SegmentList`
            defining a number of summary segments.
        url : `str`, optional, default: ``'https://segments.ligo.org'``
            URL of the segment database.

        Returns
        -------
        flagdict : `DataQualityDict
            An ordered `DataQualityDict` of (name, `DataQualityFlag`)
            pairs.
        """
        # given segmentlist
        if len(args) == 1 and isinstance(args[0], SegmentList):
            qsegs = args[0]
        elif len(args) == 1 and len(args[0]) == 2:
            qsegs = SegmentList(Segment(map(to_gps, args[0])))
        elif len(args) == 2:
            qsegs = SegmentList([Segment(map(to_gps, args))])
        else:
            raise ValueError("DataQualityDict.query_segdb must be called with "
                             "a list of flag names, and either GPS start and "
                             "stop times, or a SegmentList of query segments")
        url = kwargs.pop('url', 'https://segments.ligo.org')
        if kwargs.pop('on_error', None) is not None:
            warnings.warn("DataQualityDict.query_segdb doesn't accept the "
                          "on_error keyword argument")
        if kwargs.keys():
            raise TypeError("DataQualityDict.query_segdb has no keyword "
                            "argument '%s'" % kwargs.keys()[0])
        # parse flags
        if isinstance(flags, (str, unicode)):
            flags = flags.split(',')
        else:
            flags = flags
        # process query
        from glue.segmentdb import (segmentdb_utils as segdb_utils,
                                    query_engine as segdb_engine)
        connection = segdb_utils.setup_database(url)
        engine = segdb_engine.LdbdQueryEngine(connection)
        segdefs = []
        for flag in flags:
            dqflag = DataQualityFlag(name=flag)
            ifo = dqflag.ifo
            name = dqflag.tag
            if dqflag.version is None:
                vers = '*'
            else:
                vers = dqflag.version
            for gpsstart, gpsend in qsegs:
                if gpsend == PosInfinity or float(gpsend) == +inf:
                    gpsend = to_gps('now').seconds
                gpsstart = float(gpsstart)
                if not gpsstart.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                gpsend = float(gpsend)
                if not gpsend.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                segdefs += segdb_utils.expand_version_number(
                    engine, (ifo, name, vers, gpsstart, gpsend, 0, 0))
        segs = segdb_utils.query_segments(engine, 'segment', segdefs)
        segsum = segdb_utils.query_segments(engine, 'segment_summary', segdefs)
        # build output
        out = cls()
        for definition, segments, summary in zip(segdefs, segs, segsum):
            # parse flag name
            flag = ':'.join(map(str, definition[:3]))
            name = flag.rsplit(':', 1)[0]
            # if versionless
            if flag.endswith('*'):
                flag = name
                key = name
            # if asked for versionless, but returned a version
            elif flag not in flags and name in flags:
                key = name
            # other
            else:
                key = flag
            # define flag
            if key not in out:
                out[key] = DataQualityFlag(name=flag)
            # add segments
            out[key].known.extend(summary)
            out[key].active.extend(segments)
        return out
def dump_flags(ifos=None, segment_url=None, match=None, unmatch=None,\
               latest=False):
    """
    Returns the list of all flags defined in the database.

    Keyword rguments:
      ifo : [ str | list ]
        list of ifos to query, or str for single ifo
      segment_url : str 
        url of segment database, defaults to contents of S6_SEGMENT_SERVER
        environment variable
      match : [ str | regular pattern ]
        regular expression to search against returned flag names, e.g, 'UPV'
      unmatch : [ str | regular pattern ]
        regular expression to negatively search against returned flag names
  """

    if isinstance(ifos, str):
        ifos = [ifos]

    # get url
    if not segment_url:
        segment_url = os.getenv('S6_SEGMENT_SERVER')

    # open connection to LDBD(W)Server
    myClient = segmentdb_utils.setup_database(segment_url)

    reply = StringIO(myClient.query(squery))
    xmldoc, digest = utils.load_fileobj(reply)
    seg_def_table = lsctables.SegmentDefTable.get_table(xmldoc)

    # sort table by ifo, name and version
    seg_def_table.sort(key=lambda flag: (flag.ifos[0], flag.name, \
                                         flag.version), reverse=True)

    flags = lsctables.New(type(seg_def_table))

    for row in seg_def_table:

        # test re match
        if match and not re.search(match, row.name): continue

        # test re unmatch
        if unmatch and re.search(unmatch, row.name): continue

        # only append latest versions of multiple flags
        flatest = True
        if latest:
            # get all flags with same ifo and name
            vflags = [f for f in flags if row.name==f.name and\
                      row.get_ifos()==f.get_ifos()]
            # if later version in list, move on
            for f in vflags:
                if f.version >= row.version:
                    flatest = False
                    break
        if not flatest:
            continue

        # append those flags matching ifos requirement
        for ifo in ifos:
            if ifo in row.get_ifos():
                flags.append(row)
                break

    return flags
def grab_segments(start, end, flag,\
                  segment_url='https://segdb.ligo.caltech.edu',\
                  segment_summary=False):
    """
    Returns a segmentlist containing the segments during which the given flag
    was active in the given period.

    Arguments:

      start : int
        GPS start time
      end : int
        GPS end time
      flag : string
        'IFO:NAME:VERSION' format string

    Keyword arguments:

      segment_url : string
        url of segment database to query, default https://segdb.ligo.caltech.edu
      segment_summary : [ True | False ]
        also return the glue.segments.segmentlist defining the valid span of the
        returned segments
  """

    # set times
    start = int(math.floor(start))
    end = int(math.ceil(end))

    # set query engine
    connection = segmentdb_utils.setup_database(segment_url)
    engine = query_engine.LdbdQueryEngine(connection)

    # format flag name
    if isinstance(flag, basestring):
        flags = flag.split(',')
    else:
        flags = flag

    segdefs = []
    for f in flags:
        spec = f.split(':')
        if len(spec) < 2 or len(spec) > 3:
            raise AttributeError, "Included segements must be of the form "+\
                                  "ifo:name:version or ifo:name:*"

        ifo = spec[0]
        name = spec[1]

        if len(spec) is 3 and spec[2] is not '*':
            version = int(spec[2])
            if version < 1:
                raise AttributeError, "Segment version numbers must be greater than zero"
        else:
            version = '*'

        # expand segment definer
        segdefs += segmentdb_utils.expand_version_number(engine, (ifo, name, version, \
                                                                start, end, 0, 0))

    # query database and return
    segs = segmentdb_utils.query_segments(engine, 'segment', segdefs)
    segs = [s.coalesce() for s in segs]
    if segment_summary:
        segsums = segmentdb_utils.query_segments(engine, 'segment_summary',
                                                 segdefs)
        #segsums = reduce(operator.or_, segsums).coalesce()
        segsums = [s.coalesce() for s in segsums]
        segsummap = [segments.segmentlist() for f in flags]
        for segdef, segsum in zip(segdefs, segsums):
            try:
                fidx = flags.index(':'.join(map(str, segdef[:3])))
            except ValueError:
                fidx = flags.index(':'.join(segdef[:2]))
            segsummap[fidx].extend(segsum)
        if flag == flags[0]:
            return segs[0], segsummap[0]
        else:
            return segs, segsummap
    if flag == flags[0]:
        return segs[0]
    else:
        return segs
示例#12
0
    def query(cls, flags, *args, **kwargs):
        """Query the segment database for a set of `DataQualityFlags`.

        Parameters
        ----------
        flags : `iterable`
            A list of flag names for which to query.
        *args
            Either, two `float`-like numbers indicating the
            GPS [start, stop) interval, or a
            :class:`~gwpy.segments.segments.SegmentList`
            defining a number of summary segments.
        url : `str`, optional, default: ``'https://segdb.ligo.caltech.edu'``
            URL of the segment database.

        Returns
        -------
        flagdict : `DataQualityDict
            An ordered `DataQualityDict` of (name, `DataQualityFlag`)
            pairs.
        """
        # given segmentlist
        if len(args) == 1 and isinstance(args[0], SegmentList):
            qsegs = args[0]
        elif len(args) == 1 and len(args[0]) == 2:
            qsegs = SegmentList(Segment(args[0]))
        elif len(args) == 2:
            qsegs = SegmentList([Segment(args)])
        else:
            raise ValueError("DataQualityDict.query must be called with a "
                             "flag name, and either GPS start and stop times, "
                             "or a SegmentList of query segments")
        url = kwargs.pop('url', 'https://segdb.ligo.caltech.edu')
        if kwargs.keys():
            raise TypeError("DataQualityDict.query has no keyword argument "
                            "'%s'" % kwargs.keys()[0])
        # parse flags
        if isinstance(flags, (str, unicode)):
            flags = flags.split(',')
        else:
            flags = flags
        # process query
        from glue.segmentdb import (segmentdb_utils as segdb_utils,
                                    query_engine as segdb_engine)
        connection = segdb_utils.setup_database(url)
        engine = segdb_engine.LdbdQueryEngine(connection)
        segdefs = []
        for flag in flags:
            dqflag = DataQualityFlag(name=flag)
            ifo = dqflag.ifo
            name = dqflag.tag
            if dqflag.version is None:
                vers = '*'
            else:
                vers = dqflag.version
            for gpsstart, gpsend in qsegs:
                gpsstart = float(gpsstart)
                if not gpsstart.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                gpsend = float(gpsend)
                if not gpsend.is_integer():
                    raise ValueError("Segment database queries can only"
                                     "operate on integer GPS times")
                segdefs += segdb_utils.expand_version_number(
                    engine, (ifo, name, vers, gpsstart, gpsend, 0, 0))
        segs = segdb_utils.query_segments(engine, 'segment', segdefs)
        segsum = segdb_utils.query_segments(engine, 'segment_summary', segdefs)
        segs = [s.coalesce() for s in segs]
        segsum = [s.coalesce() for s in segsum]
        # build output
        out = cls()
        for definition, segments, summary in zip(segdefs, segs, segsum):
            # parse flag name
            flag = ':'.join(map(str, definition[:3]))
            name = flag.rsplit(':', 1)[0]
            # if versionless
            if flag.endswith('*'):
                flag = name
                key = name
            # if asked for versionless, but returned a version
            elif flag not in flags and name in flags:
                key = name
            # other
            else:
                key = flag
            # define flag
            if not key in out:
                out[key] = DataQualityFlag(name=flag)
            # add segments
            out[key].valid.extend(summary)
            out[key].active.extend(segments)
        return out