Example #1
0
 def __init__(self, conn):
     object.__init__(self)
     self.conn = conn
     self.cursor = StatementCursor(self.conn)
     self.current = None
     self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
     self.env = FamilyEnvironment(self.conn)
Example #2
0
 def __init__(self, conn):
     object.__init__(self)
     self.conn = conn
     #self.suites = Suites(conn).list()
     self.cursor = StatementCursor(self.conn)
     self.suites = [r.suite for r in self.cursor.select(table='suites')]
     self.current = None
     self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
     self.env = FamilyEnvironment(self.conn)
Example #3
0
 def __init__(self, conn):
     object.__init__(self)
     self.conn = conn
     self.cursor = StatementCursor(self.conn)
     self.current = None
     self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
     self.env = FamilyEnvironment(self.conn)
Example #4
0
 def __init__(self, conn):
     object.__init__(self)
     self.conn = conn
     # self.suites = Suites(conn).list()
     self.cursor = StatementCursor(self.conn)
     self.suites = [r.suite for r in self.cursor.select(table="suites")]
     self.current = None
     self.parent = SimpleRelation(self.conn, "family_parent", "family")
     self.env = FamilyEnvironment(self.conn)
Example #5
0
class Family(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.current = None
        self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
        self.env = FamilyEnvironment(self.conn)
        
    def set_family(self, family):
        self.current = family
        self.parent.set_current(family)
        self.env.set_family(family)

    def _check_family(self, family):
        if family is not None:
            return family
        else:
            family = self.current
        if family is None:
            raise Error, 'either pass a family argument or call set_family on this object'
        return family
    
    def get_related_families(self, families=[]):
        rows = self.cursor.select(table='family_parent')
        graph = kjGraph([(r.family, r.parent) for r in rows])
        dfamilies = Set()
        for fam in families:
            dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
        return dfamilies

    def parent_rows(self, family=None):
        family = self._check_family(family)
        self.parent.set_clause(family)
        rows = self.parent.cmd.select(fields=['parent'], order='parent')
        self.parent.reset_clause()
        return rows

    def parents(self, family=None):
        family = self._check_family(family)
        rows = self.parent_rows(family)
        return [x.parent for x in rows]
    
    def environment_rows(self, family=None):
        family = self._check_family(family)
        clause = Eq('family', family)
        args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
        return self.env.cursor.select(**args)

    def family_rows(self):
        return self.cursor.select(fields=['family'], table='families', order='family')

    def all_families(self):
        return [r.family for r in self.family_rows()]

    def get_all_defaults(self):
        suite_cursor = SuiteCursor(self.conn)
        suites = suite_cursor.get_suites()
        stmt = select_multisuite_union(suites, 'variables')
        print stmt
        self.cursor.execute(stmt)
        return self.cursor.fetchall()

    def create_family(self, family):
        if family not in self.all_families():
            self.cursor.insert(table='families', data=dict(family=family))
        else:
            raise ExistsError, '%s already exists' % family

    def delete_family(self, family=None):
        family = self._check_family(family)
        self.cursor.execute("select * from delete_family('%s')" % family)
        
    def insert_parents(self, parents, family=None):
        family = self._check_family(family)
        self.parent.insert('parent', parents)

    def delete_parents(self, parents=[], family=None):
        family = self._check_family(family)
        if not parents:
            parents = self.parents()
        if not parents:
            return
        table= 'family_parent'
        clause = Eq('family', family) & In('parent', parents)
        self.cursor.delete(table=table, clause=clause)
        
    def FamilyData(self, families=[]):
        # change sep here
        sep = PAELLA_TRAIT_NAME_SEP
        # we don't know what to do here
        # it is possible to have an empty
        # list of families, and if that's the
        # case we don't need to make the
        # list of [self.current] .  I need to look
        # for everywhere this method is called.
        # In the installer, the family is never set,
        # and we use the list of families provided
        # by the profile and the machine.  In this
        # case, the families argument will always
        # be a list, empty or not.
        # I can't think of any other circumstance
        # where this method would be called outside
        # of the installer, or a script, and the script
        # should be using either a profile or machine
        # to get the list of families anyway, make the
        # point moot.  I will probably remove this part
        # of the code in the near future, once I'm sure
        # that there's no reason to pass None to the
        # families argument.
        if families is None:
            families = [self.current]
        all = self.make_familylist(families)
        superdict = {}
        for f in all:
            superdict.update(self.env.make_tagdict(f, sep=sep))
        return superdict
            
        
            
    def make_familylist(self, families):
        deps = families
        all = list(self.get_related_families(families))
        setfun = self.set_family
        parfun = self.parents
        return make_deplist(deps, all, setfun, parfun)

    def export_family(self, family=None):
        if family is None:
            family = self.current
        # row isn't used, except to determine that the family exists
        row = self.cursor.select_row(table='families', clause=Eq('family', family))
        element = FamilyElement(family)
        element.append_parents(self.parents(family))
        element.append_variables(self.environment_rows(family))
        return element

    def write_family(self, family, path):
        fxml = file(join(path, '%s.xml' % family), 'w')
        data = self.export_family(family)
        data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
        fxml.close()
        
    def export_families(self, path):
        families = self.all_families()
        self.report_total_families(len(families))
        for f in families:
            self.write_family(f, path)
            self.report_family_exported(f, path)

    def import_family(self, element):
        parsed = FamilyParser(element)
        print 'inserting family', parsed.name
        all = self.all_families()
        for p in parsed.parents:
            if p not in all:
                print 'insertion failed for', parsed.name
                raise UnbornError
        self.create_family(parsed.name)
        self.set_family(parsed.name)
        self.insert_parents(parsed.parents)
        row = dict(family=parsed.name)
        for var in parsed.environ:
            row.update(var)
            self.cursor.insert(table='family_environment', data=row)

    def _import_family_xml(self, xmlfile):
        xml = parse_file(xmlfile)
        elements = xml.getElementsByTagName('family')
        if len(elements) != 1:
            raise Error, 'bad number of family tags %s' % len(elements)
        element = elements[0]
        return element
    
            
    def import_family_xml(self, xmlfile):
        element = self._import_family_xml(xmlfile)
        self.import_family(element)
        
    def import_families(self, path):
        xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
        families = []
        for f in xmlfiles:
            element = self._import_family_xml(f)
            families.append(element)
        while len(families):
            f = families[0]
            try:
                self.import_family(f)
            except UnbornError:
                families.append(f)
            del families[0]
        print len(families), 'families inserted'

    def getVariablesConfig(self, family=None):
        family = self._check_family(family)
        return FamilyVariablesConfig(self.conn, family)
    
    def deleteVariable(self, trait, name, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        self.env.cursor.delete(clause=clause)

    def insertVariable(self, trait, name, value, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        testrows = self.cursor.select(table='family_environment', clause=clause)
        if not len(testrows):
            data['value'] = value
            self.cursor.insert(table='family_environment', data=data)
        
    def report_family_exported(self, family, path):
        print 'family %s exported to %s' % (family, path)

    def report_total_families(self, total):
        print 'exporting %d families' % total
Example #6
0
 def __init__(self, conn, suite, table, name='_TraitRelation'):
     SimpleRelation.__init__(self, conn, table, 'trait', name=name)
     self.suite = suite
     self.current_trait = None
Example #7
0
 def __init__(self, conn):
     SimpleRelation.__init__(self,
                             conn,
                             'profile_trait',
                             'profile',
                             name='ProfileTrait')
Example #8
0
class Family(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        #self.suites = Suites(conn).list()
        self.cursor = StatementCursor(self.conn)
        self.suites = [r.suite for r in self.cursor.select(table='suites')]
        self.current = None
        self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
        self.env = FamilyEnvironment(self.conn)
        
    def set_family(self, family):
        self.current = family
        self.parent.set_current(family)
        self.env.set_family(family)

    def _check_family(self, family):
        if family is not None:
            return family
        else:
            family = self.current
        if family is None:
            raise Error, 'either pass a family arguement or call set_family on this object'
        return family
    
    def add_family(self, family, type='general'):
        pass

    def get_related_families(self, families=[]):
        rows = self.cursor.select(table='family_parent')
        graph = kjGraph([(r.family, r.parent) for r in rows])
        dfamilies = Set()
        for fam in families:
            dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
        return dfamilies

    def parent_rows(self, family=None):
        family = self._check_family(family)
        self.parent.set_clause(family)
        rows = self.parent.cmd.select(fields=['parent'], order='parent')
        self.parent.reset_clause()
        return rows

    def parents(self, family=None):
        family = self._check_family(family)
        rows = self.parent_rows(family)
        return [x.parent for x in rows]
    
    def environment_rows(self, family=None):
        family = self._check_family(family)
        clause = Eq('family', family)
        args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
        return self.env.cursor.select(**args)

    def family_rows(self):
        return self.cursor.select(fields=['family'], table='families', order='family')

    def all_families(self):
        return [r.family for r in self.family_rows()]

    def get_all_defaults(self):
        stmt = select_multisuite_union(self.suites, 'variables')
        print stmt
        self.cursor.execute(stmt)
        return self.cursor.fetchall()

    def create_family(self, family):
        if family not in self.all_families():
            self.cursor.insert(table='families', data=dict(family=family))
        else:
            raise ExistsError, '%s already exists' % family

    def insert_parents(self, parents, family=None):
        family = self._check_family(family)
        self.parent.insert('parent', parents)

    def FamilyData(self, families=[]):
        if families is None:
            families = [self.current]
        all = self.make_familylist(families)
        superdict = {}
        for f in all:
            superdict.update(self.env.make_tagdict(f))
        return superdict
            
        
            
    def make_familylist(self, families):
        deps = families
        all = list(self.get_related_families(families))
        setfun = self.set_family
        parfun = self.parents
        return make_deplist(deps, all, setfun, parfun)

    def export_family(self, family=None):
        if family is None:
            family = self.current
        element = FamilyElement(family)
        element.append_parents(self.parents(family))
        element.append_variables(self.environment_rows(family))
        return element

    def write_family(self, family, path):
        fxml = file(join(path, '%s.xml' % family), 'w')
        data = self.export_family(family)
        data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
        fxml.close()
        
    def export_families(self, path):
        families = self.all_families()
        for f in families:
            self.write_family(f, path)
            

    def import_family(self, element):
        parsed = FamilyParser(element)
        print 'inserting family', parsed.name
        all = self.all_families()
        for p in parsed.parents:
            if p not in all:
                print 'insertion failed for', parsed.name
                raise UnbornError
        self.create_family(parsed.name)
        self.set_family(parsed.name)
        self.insert_parents(parsed.parents)
        row = dict(family=parsed.name)
        for var in parsed.environ:
            row.update(var)
            self.cursor.insert(table='family_environment', data=row)

    def _import_family_xml(self, xmlfile):
        xml = parse_file(xmlfile)
        elements = xml.getElementsByTagName('family')
        if len(elements) != 1:
            raise Error, 'bad number of family tags %s' % len(elements)
        element = elements[0]
        return element
    
            
    def import_family_xml(self, xmlfile):
        element = self._import_family_xml(xmlfile)
        self.import_family(element)
        
    def import_families(self, path):
        xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
        families = []
        for f in xmlfiles:
            element = self._import_family_xml(f)
            families.append(element)
        while len(families):
            f = families[0]
            try:
                self.import_family(f)
            except UnbornError:
                families.append(f)
            del families[0]
        print len(families), 'families inserted'

    def getVariablesConfig(self, family=None):
        family = self._check_family(family)
        return FamilyVariablesConfig(self.conn, family)
    
    def deleteVariable(self, trait, name, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        self.env.cursor.delete(clause=clause)

    def insertVariable(self, trait, name, value, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        testrows = self.cursor.select(table='family_environment', clause=clause)
        if not len(testrows):
            data['value'] = value
            self.cursor.insert(table='family_environment', data=data)
Example #9
0
 def __init__(self, conn):
     SimpleRelation.__init__(self, conn, 'profile_trait',
                             'profile', name='ProfileTrait')
Example #10
0
class Family(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.current = None
        self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
        self.env = FamilyEnvironment(self.conn)
        
    def set_family(self, family):
        self.current = family
        self.parent.set_current(family)
        self.env.set_family(family)

    def _check_family(self, family):
        if family is not None:
            return family
        else:
            family = self.current
        if family is None:
            raise Error, 'either pass a family arguement or call set_family on this object'
        return family
    
    def add_family(self, family, type='general'):
        pass

    def get_related_families(self, families=[]):
        rows = self.cursor.select(table='family_parent')
        graph = kjGraph([(r.family, r.parent) for r in rows])
        dfamilies = Set()
        for fam in families:
            dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
        return dfamilies

    def parent_rows(self, family=None):
        family = self._check_family(family)
        self.parent.set_clause(family)
        rows = self.parent.cmd.select(fields=['parent'], order='parent')
        self.parent.reset_clause()
        return rows

    def parents(self, family=None):
        family = self._check_family(family)
        rows = self.parent_rows(family)
        return [x.parent for x in rows]
    
    def environment_rows(self, family=None):
        family = self._check_family(family)
        clause = Eq('family', family)
        args = dict(fields=['trait', 'name', 'value'], clause=clause, order=['trait', 'name'])
        return self.env.cursor.select(**args)

    def family_rows(self):
        return self.cursor.select(fields=['family'], table='families', order='family')

    def all_families(self):
        return [r.family for r in self.family_rows()]

    def get_all_defaults(self):
        suite_cursor = SuiteCursor(self.conn)
        suites = suite_cursor.get_suites()
        stmt = select_multisuite_union(suites, 'variables')
        print stmt
        self.cursor.execute(stmt)
        return self.cursor.fetchall()

    def create_family(self, family):
        if family not in self.all_families():
            self.cursor.insert(table='families', data=dict(family=family))
        else:
            raise ExistsError, '%s already exists' % family

    def insert_parents(self, parents, family=None):
        family = self._check_family(family)
        self.parent.insert('parent', parents)

    def FamilyData(self, families=[]):
        if families is None:
            families = [self.current]
        all = self.make_familylist(families)
        superdict = {}
        for f in all:
            superdict.update(self.env.make_tagdict(f))
        return superdict
            
        
            
    def make_familylist(self, families):
        deps = families
        all = list(self.get_related_families(families))
        setfun = self.set_family
        parfun = self.parents
        return make_deplist(deps, all, setfun, parfun)

    def export_family(self, family=None):
        if family is None:
            family = self.current
        element = FamilyElement(family)
        element.append_parents(self.parents(family))
        element.append_variables(self.environment_rows(family))
        return element

    def write_family(self, family, path):
        fxml = file(join(path, '%s.xml' % family), 'w')
        data = self.export_family(family)
        data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
        fxml.close()
        
    def export_families(self, path):
        families = self.all_families()
        self.report_total_families(len(families))
        for f in families:
            self.write_family(f, path)
            self.report_family_exported(f, path)

    def import_family(self, element):
        parsed = FamilyParser(element)
        print 'inserting family', parsed.name
        all = self.all_families()
        for p in parsed.parents:
            if p not in all:
                print 'insertion failed for', parsed.name
                raise UnbornError
        self.create_family(parsed.name)
        self.set_family(parsed.name)
        self.insert_parents(parsed.parents)
        row = dict(family=parsed.name)
        for var in parsed.environ:
            row.update(var)
            self.cursor.insert(table='family_environment', data=row)

    def _import_family_xml(self, xmlfile):
        xml = parse_file(xmlfile)
        elements = xml.getElementsByTagName('family')
        if len(elements) != 1:
            raise Error, 'bad number of family tags %s' % len(elements)
        element = elements[0]
        return element
    
            
    def import_family_xml(self, xmlfile):
        element = self._import_family_xml(xmlfile)
        self.import_family(element)
        
    def import_families(self, path):
        xmlfiles = [join(path, x) for x in os.listdir(path) if x[-4:] == '.xml']
        families = []
        for f in xmlfiles:
            element = self._import_family_xml(f)
            families.append(element)
        while len(families):
            f = families[0]
            try:
                self.import_family(f)
            except UnbornError:
                families.append(f)
            del families[0]
        print len(families), 'families inserted'

    def getVariablesConfig(self, family=None):
        family = self._check_family(family)
        return FamilyVariablesConfig(self.conn, family)
    
    def deleteVariable(self, trait, name, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        self.env.cursor.delete(clause=clause)

    def insertVariable(self, trait, name, value, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k,v in data.items()])
        testrows = self.cursor.select(table='family_environment', clause=clause)
        if not len(testrows):
            data['value'] = value
            self.cursor.insert(table='family_environment', data=data)
        
    def report_family_exported(self, family, path):
        print 'family %s exported to %s' % (family, path)

    def report_total_families(self, total):
        print 'exporting %d families' % total
Example #11
0
 def __init__(self, conn, suite, table, name='_TraitRelation'):
     SimpleRelation.__init__(self, conn, table, 'trait', name=name)
     self.suite = suite
     self.current_trait = None
Example #12
0
 def __init__(self, conn, suite, table, name="_TraitRelation"):
     SimpleRelation.__init__(self, conn, table, "trait", name=name)
     self.suite = suite
     self.current_trait = None
Example #13
0
class Family(object):
    def __init__(self, conn):
        object.__init__(self)
        self.conn = conn
        self.cursor = StatementCursor(self.conn)
        self.current = None
        self.parent = SimpleRelation(self.conn, 'family_parent', 'family')
        self.env = FamilyEnvironment(self.conn)

    def set_family(self, family):
        self.current = family
        self.parent.set_current(family)
        self.env.set_family(family)

    def _check_family(self, family):
        if family is not None:
            return family
        else:
            family = self.current
        if family is None:
            raise Error, 'either pass a family argument or call set_family on this object'
        return family

    def get_related_families(self, families=[]):
        rows = self.cursor.select(table='family_parent')
        graph = kjGraph([(r.family, r.parent) for r in rows])
        dfamilies = Set()
        for fam in families:
            dfamilies |= Set([fam]) | Set(graph.reachable(fam).items())
        return dfamilies

    def parent_rows(self, family=None):
        family = self._check_family(family)
        self.parent.set_clause(family)
        rows = self.parent.cmd.select(fields=['parent'], order='parent')
        self.parent.reset_clause()
        return rows

    def parents(self, family=None):
        family = self._check_family(family)
        rows = self.parent_rows(family)
        return [x.parent for x in rows]

    def environment_rows(self, family=None):
        family = self._check_family(family)
        clause = Eq('family', family)
        args = dict(fields=['trait', 'name', 'value'],
                    clause=clause,
                    order=['trait', 'name'])
        return self.env.cursor.select(**args)

    def family_rows(self):
        return self.cursor.select(fields=['family'],
                                  table='families',
                                  order='family')

    def all_families(self):
        return [r.family for r in self.family_rows()]

    def get_all_defaults(self):
        suite_cursor = SuiteCursor(self.conn)
        suites = suite_cursor.get_suites()
        stmt = select_multisuite_union(suites, 'variables')
        print stmt
        self.cursor.execute(stmt)
        return self.cursor.fetchall()

    def create_family(self, family):
        if family not in self.all_families():
            self.cursor.insert(table='families', data=dict(family=family))
        else:
            raise ExistsError, '%s already exists' % family

    def delete_family(self, family=None):
        family = self._check_family(family)
        self.cursor.execute("select * from delete_family('%s')" % family)

    def insert_parents(self, parents, family=None):
        family = self._check_family(family)
        self.parent.insert('parent', parents)

    def delete_parents(self, parents=[], family=None):
        family = self._check_family(family)
        if not parents:
            parents = self.parents()
        if not parents:
            return
        table = 'family_parent'
        clause = Eq('family', family) & In('parent', parents)
        self.cursor.delete(table=table, clause=clause)

    def FamilyData(self, families=[]):
        # change sep here
        sep = PAELLA_TRAIT_NAME_SEP
        # we don't know what to do here
        # it is possible to have an empty
        # list of families, and if that's the
        # case we don't need to make the
        # list of [self.current] .  I need to look
        # for everywhere this method is called.
        # In the installer, the family is never set,
        # and we use the list of families provided
        # by the profile and the machine.  In this
        # case, the families argument will always
        # be a list, empty or not.
        # I can't think of any other circumstance
        # where this method would be called outside
        # of the installer, or a script, and the script
        # should be using either a profile or machine
        # to get the list of families anyway, make the
        # point moot.  I will probably remove this part
        # of the code in the near future, once I'm sure
        # that there's no reason to pass None to the
        # families argument.
        if families is None:
            families = [self.current]
        all = self.make_familylist(families)
        superdict = {}
        for f in all:
            superdict.update(self.env.make_tagdict(f, sep=sep))
        return superdict

    def make_familylist(self, families):
        deps = families
        all = list(self.get_related_families(families))
        setfun = self.set_family
        parfun = self.parents
        return make_deplist(deps, all, setfun, parfun)

    def export_family(self, family=None):
        if family is None:
            family = self.current
        # row isn't used, except to determine that the family exists
        row = self.cursor.select_row(table='families',
                                     clause=Eq('family', family))
        element = FamilyElement(family)
        element.append_parents(self.parents(family))
        element.append_variables(self.environment_rows(family))
        return element

    def write_family(self, family, path):
        fxml = file(join(path, '%s.xml' % family), 'w')
        data = self.export_family(family)
        data.writexml(fxml, indent='\t', newl='\n', addindent='\t')
        fxml.close()

    def export_families(self, path):
        families = self.all_families()
        self.report_total_families(len(families))
        for f in families:
            self.write_family(f, path)
            self.report_family_exported(f, path)

    def import_family(self, element):
        parsed = FamilyParser(element)
        print 'inserting family', parsed.name
        all = self.all_families()
        for p in parsed.parents:
            if p not in all:
                print 'insertion failed for', parsed.name
                raise UnbornError
        self.create_family(parsed.name)
        self.set_family(parsed.name)
        self.insert_parents(parsed.parents)
        row = dict(family=parsed.name)
        for var in parsed.environ:
            row.update(var)
            self.cursor.insert(table='family_environment', data=row)

    def _import_family_xml(self, xmlfile):
        xml = parse_file(xmlfile)
        elements = xml.getElementsByTagName('family')
        if len(elements) != 1:
            raise Error, 'bad number of family tags %s' % len(elements)
        element = elements[0]
        return element

    def import_family_xml(self, xmlfile):
        element = self._import_family_xml(xmlfile)
        self.import_family(element)

    def import_families(self, path):
        xmlfiles = [
            join(path, x) for x in os.listdir(path) if x[-4:] == '.xml'
        ]
        families = []
        for f in xmlfiles:
            element = self._import_family_xml(f)
            families.append(element)
        while len(families):
            f = families[0]
            try:
                self.import_family(f)
            except UnbornError:
                families.append(f)
            del families[0]
        print len(families), 'families inserted'

    def getVariablesConfig(self, family=None):
        family = self._check_family(family)
        return FamilyVariablesConfig(self.conn, family)

    def deleteVariable(self, trait, name, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k, v in data.items()])
        self.env.cursor.delete(clause=clause)

    def insertVariable(self, trait, name, value, family=None):
        family = self._check_family(family)
        data = dict(family=family, trait=trait, name=name)
        clause = reduce(and_, [Eq(k, v) for k, v in data.items()])
        testrows = self.cursor.select(table='family_environment',
                                      clause=clause)
        if not len(testrows):
            data['value'] = value
            self.cursor.insert(table='family_environment', data=data)

    def report_family_exported(self, family, path):
        print 'family %s exported to %s' % (family, path)

    def report_total_families(self, total):
        print 'exporting %d families' % total