class instance of Config():

def __init__(self): 

    self.option = CmdOptions()

    self._parser = optparse.OptionParser(

        usage="usage: %prog [options] [query] [filenames of tests]")

    self._conftest = Conftest()

    self._initialized = False

def addoptions(self, groupname, *specs): 

    """ add a named group of options to the current testing session. 

            This function gets invoked during testing session initialization. 

        """ 

    for spec in specs:

        for shortopt in spec._short_opts:

            if not shortopt.isupper(): 

                raise ValueError(

                    "custom options must be capital letter "

                    "got %r" %(spec,)

                )

    return self._addoptions(groupname, *specs)

def get_collector_trail(self, collector):

    """ provide a trail relative to the topdir, 

            which can be used to reconstruct the

            collector (possibly on a different host

            starting from a different topdir). 

        """ 

    chain = collector.listchain()

    relpath = chain[0].fspath.relto(self.topdir)

    if not relpath:

        if chain[0].fspath == self.topdir:

            relpath = "."

        else:

            raise ValueError("%r not relative to %s" 

                     %(chain[0], self.topdir))

    return relpath, tuple([x.name for x in chain[1:]])

def getcolitems(self):

    """ return initial collectors. """

    trails = getattr(self, '_coltrails', None)

    return [self._getcollector(path) for path in (trails or self.args)]

def getvalue(self, name, path=None): 

    """ return 'name' value looked up from the 'options'

            and then from the first conftest file found up 

            the path (including the path itself). 

            if path is None, lookup the value in the initial

            conftest modules found during command line parsing. 

        """

    try:

        return getattr(self.option, name)

    except AttributeError:

        return self._conftest.rget(name, path)

def getvalue_pathlist(self, name, path=None):

    """ return a matching value, which needs to be sequence

            of filenames that will be returned as a list of Path

            objects (they can be relative to the location 

            where they were found).

        """

    try:

        return getattr(self.option, name)

    except AttributeError:

        try:

            mod, relroots = self._conftest.rget_with_confmod(name, path)

        except KeyError:

            return None

        modpath = py.path.local(mod.__file__).dirpath()

        return [modpath.join(x, abs=True) for x in relroots]

def initsession(self):

    """ return an initialized session object. """

    cls = self._getsessionclass()

    session = cls(self)

    session.fixoptions()

    return session

def parse(self, args): 

    """ parse cmdline arguments into this config object. 

            Note that this can only be called once per testing process. 

        """ 

    assert not self._initialized, (

            "can only parse cmdline args once per Config object")

    self._initialized = True

    adddefaultoptions(self)

    self._conftest.setinitial(args) 

    args = [str(x) for x in args]

    cmdlineoption, args = self._parser.parse_args(args) 

    self.option.__dict__.update(vars(cmdlineoption))

    if not args:

        args.append(py.std.os.getcwd())

    self.topdir = gettopdir(args)

    self.args = args