Ejemplo n.º 1
0
def load_dbf(tableName, load):
    fn = os.path.join(settings.SITE.legacy_data_path, '%s.DBF' % tableName)
    f = dbfreader.DBFFile(fn, codepage="cp850")
    logger.info("Loading %d records from %s...", len(f), fn)
    f.open()
    for dbfrow in f:
        i = load(dbfrow)
        if i is not None:
            i = settings.TIM2LINO_LOCAL(tableName, i)
            if i is not None:
                try_full_clean(i)
                yield i

                #~ try:
                #~ i.save()
                #~ except Exception,e:
                #~ dblogger.warning("Failed to save %s from %s : %s",obj2str(i),dbfrow,e)
                #~ dblogger.exception(e)
    f.close()
Ejemplo n.º 2
0
    def load_dbf(self, tableName, row2obj=None):
        if row2obj is None:
            row2obj = getattr(self, 'load_' + tableName[-3:].lower())
        fn = self.dbpath
        if self.archive_name is not None:
            if tableName in self.archived_tables:
                fn = os.path.join(fn, self.archive_name)
        fn = os.path.join(fn, tableName)
        fn += dd.plugins.tim2lino.dbf_table_ext
        if dd.plugins.tim2lino.use_dbf_py:
            dd.logger.info("Loading %s...", fn)
            import dbf  # http://pypi.python.org/pypi/dbf/
            # table = dbf.Table(fn)
            table = dbf.Table(fn, codepage=self.codepage)
            # table.use_deleted = False
            table.open()
            # print table.structure()
            dd.logger.info("Loading %d records from %s (%s)...",
                           len(table), fn, table.codepage)
            for record in table:
                if not dbf.is_deleted(record):
                    try:
                        yield row2obj(record)
                    except Exception as e:
                        dd.logger.warning(
                            "Failed to load record %s from %s : %s",
                            record, tableName, e)

                    # i = row2obj(record)
                    # if i is not None:
                    #     yield settings.TIM2LINO_LOCAL(tableName, i)
            table.close()
        elif dd.plugins.tim2lino.use_dbfread:
            dd.logger.info("Loading readonly %s...", fn)
            from dbfread import DBF
            dbf = DBF(fn)
            for record in dbf:
                d = { f.name.lower() : record[f.name] for f in dbf.fields}
                d = AttrDict(d)
                try:
                    yield row2obj(d)
                except Exception as e:
                    dd.logger.warning(
                        "Failed to load record %s from %s : %s",
                        record, tableName, e)

        else:
            f = dbfreader.DBFFile(fn, codepage="cp850")
            dd.logger.info("Loading %d records from %s...", len(f), fn)
            f.open(deleted=True)
            # must set deleted=True and then filter them out myself
            # because big tables can raise
            # RuntimeError: maximum recursion depth exceeded in cmp
            for dbfrow in f:
                if not dbfrow.deleted():
                    try:
                        i = row2obj(dbfrow)
                        if i is not None:
                            yield settings.TIM2LINO_LOCAL(tableName, i)
                    except Exception as e:
                        traceback.print_exc(e)
                        dd.logger.warning("Failed to load record %s : %s",
                                          dbfrow, e)
            f.close()

        self.after_load(tableName)