def __init__(self): mapping_file = os.path.join(os.path.dirname(__file__), '..', 'defaultmapping.py') mappings = {} execfile(mapping_file, mappings) self.tag_mapping = TagMapper([ m for n, m in mappings.iteritems() if isinstance(m, imposm.mapping.Mapping) ])
def __init__(self): mapping_file = os.path.join(os.path.dirname(__file__), '..', 'defaultmapping.py') mappings = {} execfile(mapping_file, mappings) self.tag_mapping = TagMapper([m for n, m in mappings.iteritems() if isinstance(m, imposm.mapping.Mapping)])
def test_multiple_mappings(self): roads = LineStrings(name='roads', mapping={ 'highway': ('secondary', ), 'railway': ('tram', ), }) tag_mapping = TagMapper([roads]) for_ways = tag_mapping.for_ways eq_mapping(for_ways({'unknown': 'baz'}), []) eq_mapping(for_ways({'highway': 'unknown'}), []) eq_mapping(for_ways({'highway': 'secondary'}), [(('highway', 'secondary'), ('roads', ))]) eq_mapping(for_ways({ 'highway': 'secondary', 'railway': 'tram' }), [(('railway', 'tram'), ('roads', )), (('highway', 'secondary'), ('roads', ))])
class TestTagMapper(object): def __init__(self): mapping_file = os.path.join(os.path.dirname(__file__), '..', 'defaultmapping.py') mappings = {} execfile(mapping_file, mappings) self.tag_mapping = TagMapper([m for n, m in mappings.iteritems() if isinstance(m, imposm.mapping.Mapping)]) def test_tag_filter_nodes(self): tag_filter_for_nodes = self.tag_mapping.tag_filter_for_nodes() tagfilter = lambda x: tag_filter_for_nodes(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'place': 'unknown'}), {}) eq_(tagfilter({'name': 'foo', 'place': 'village'}), {'name': 'foo', 'place': 'village'}) eq_(tagfilter({'name': 'foo', 'place': 'village', 'population': '1000'}), {'name': 'foo', 'place': 'village', 'population': '1000'}) eq_(tagfilter({'name': 'foo', 'place': 'village', 'highway': 'unknown'}), {'name': 'foo', 'place': 'village'}) eq_(tagfilter({'name': 'foo', 'place': 'village', 'highway': 'bus_stop'}), {'name': 'foo', 'place': 'village', 'highway': 'bus_stop'}) def test_tag_filter_ways(self): tag_filter_for_ways = self.tag_mapping.tag_filter_for_ways() tagfilter = lambda x: tag_filter_for_ways(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'highway': 'unknown'}), {}) eq_(tagfilter({'name': 'foo', 'highway': 'track'}), {'name': 'foo', 'highway': 'track'}) eq_(tagfilter({'name': 'foo', 'highway': 'track', 'oneway': 'yes', 'tunnel': '1'}), {'name': 'foo', 'highway': 'track', 'oneway': 'yes', 'tunnel': '1'}) eq_(tagfilter({'name': 'foo', 'place': 'village', 'highway': 'track'}), {'name': 'foo', 'highway': 'track'}) eq_(tagfilter({'name': 'foo', 'railway': 'tram', 'highway': 'secondary'}), {'name': 'foo', 'railway': 'tram', 'highway': 'secondary'}) # with __any__ value eq_(tagfilter({'name': 'foo', 'building': 'yes'}), {'name': 'foo', 'building': 'yes'}) eq_(tagfilter({'name': 'foo', 'building': 'whatever'}), {'name': 'foo', 'building': 'whatever'}) def test_tag_filter_relations(self): tag_filter_for_relations = self.tag_mapping.tag_filter_for_relations() tagfilter = lambda x: tag_filter_for_relations(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'unknown'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'farm'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'farm', 'type': 'multipolygon'}), {'name': 'foo', 'landuse': 'farm', 'type': 'multipolygon'}) # skip multipolygon with filtered tags, otherwise tags from longest way would be used eq_(tagfilter({'name': 'foo', 'landuse': 'unknown', 'type': 'multipolygon'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'park', 'type': 'multipolygon'}), {'name': 'foo', 'type': 'multipolygon', 'landuse': 'park'}) eq_(tagfilter({'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'multipolygon'}), {'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'multipolygon'}) # boundary relation for boundary eq_(tagfilter({'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'boundary'}), {'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'boundary'}) # boundary relation for non boundary eq_(tagfilter({'name': 'foo', 'landuse': 'farm', 'type': 'boundary'}), {}) # skip boundary with filtered tags, otherwise tags from longest way would be used eq_(tagfilter({'name': 'foo', 'boundary': 'unknown', 'type': 'boundary'}), {}) eq_(tagfilter({'name': 'foo', 'boundary': 'administrative', 'type': 'boundary'}), {'name': 'foo', 'boundary': 'administrative', 'type': 'boundary'}) def test_mapping_for_nodes(self): for_nodes = self.tag_mapping.for_nodes eq_mapping(for_nodes({'unknown': 'baz'}), []) eq_mapping(for_nodes({'place': 'unknown'}), []) eq_mapping(for_nodes({'place': 'city'}), [(('place', 'city'), ('places',))]) eq_mapping(for_nodes({'place': 'city', 'highway': 'unknown'}), [(('place', 'city'), ('places',))]) eq_mapping(for_nodes({'place': 'city', 'highway': 'bus_stop'}), [(('place', 'city'), ('places',)), (('highway', 'bus_stop'), ('transport_points',))]) def test_mapping_for_ways(self): for_ways = self.tag_mapping.for_ways eq_mapping(for_ways({'unknown': 'baz'}), []) eq_mapping(for_ways({'highway': 'unknown'}), []) eq_mapping(for_ways({'highway': 'track'}), [(('highway', 'track'), ('minorroads',))]) eq_mapping(for_ways({'highway': 'secondary', 'railway': 'tram'}), [(('railway', 'tram'), ('railways',)), (('highway', 'secondary'), ('mainroads',))]) eq_mapping(for_ways({'highway': 'footway'}), [(('highway', 'footway'), ('minorroads',)), (('highway', 'footway'), ('landusages',))]) eq_mapping(for_ways({'highway': 'footway', 'landuse': 'park'}), [(('highway', 'footway'), ('minorroads',)), (('landuse', 'park'), ('landusages',))]) def test_mapping_for_relation(self): for_relations = self.tag_mapping.for_relations eq_mapping(for_relations({'unknown': 'baz'}), []) eq_mapping(for_relations({'landuse': 'unknown'}), []) eq_mapping(for_relations({'landuse': 'farm'}), [(('landuse', 'farm'), ('landusages',))]) eq_mapping(for_relations({'landuse': 'farm', 'highway': 'secondary'}), [(('landuse', 'farm'), ('landusages',))]) eq_mapping(for_relations({'landuse': 'farm', 'aeroway': 'apron'}), [(('aeroway', 'apron'), ('transport_areas',)), (('landuse', 'farm'), ('landusages',))]) eq_mapping(for_relations({'boundary': 'administrative', 'admin_level': '8'}), [(('boundary', 'administrative'), ('admin',))]) def test_multiple_mappings(self): roads = LineStrings( name = 'roads', mapping = { 'highway': ('secondary', ), 'railway': ('tram', ), } ) tag_mapping = TagMapper([roads]) for_ways = tag_mapping.for_ways eq_mapping(for_ways({'unknown': 'baz'}), []) eq_mapping(for_ways({'highway': 'unknown'}), []) eq_mapping(for_ways({'highway': 'secondary'}), [(('highway', 'secondary'), ('roads',))]) eq_mapping(for_ways({'highway': 'secondary', 'railway': 'tram'}), [(('railway', 'tram'), ('roads',)), ]) # returns only one mapping
class TestTagMapper(object): def __init__(self): mapping_file = os.path.join(os.path.dirname(__file__), '..', 'defaultmapping.py') mappings = {} execfile(mapping_file, mappings) self.tag_mapping = TagMapper([ m for n, m in mappings.iteritems() if isinstance(m, imposm.mapping.Mapping) ]) def test_tag_filter_nodes(self): tag_filter_for_nodes = self.tag_mapping.tag_filter_for_nodes() tagfilter = lambda x: tag_filter_for_nodes(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'place': 'unknown'}), {}) eq_(tagfilter({ 'name': 'foo', 'place': 'village' }), { 'name': 'foo', 'place': 'village' }) eq_( tagfilter({ 'name': 'foo', 'place': 'village', 'population': '1000' }), { 'name': 'foo', 'place': 'village', 'population': '1000' }) eq_( tagfilter({ 'name': 'foo', 'place': 'village', 'highway': 'unknown' }), { 'name': 'foo', 'place': 'village' }) eq_( tagfilter({ 'name': 'foo', 'place': 'village', 'highway': 'bus_stop' }), { 'name': 'foo', 'place': 'village', 'highway': 'bus_stop' }) def test_tag_filter_ways(self): tag_filter_for_ways = self.tag_mapping.tag_filter_for_ways() tagfilter = lambda x: tag_filter_for_ways(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'highway': 'unknown'}), {}) eq_(tagfilter({ 'name': 'foo', 'highway': 'track' }), { 'name': 'foo', 'highway': 'track' }) eq_( tagfilter({ 'name': 'foo', 'highway': 'track', 'oneway': 'yes', 'tunnel': '1' }), { 'name': 'foo', 'highway': 'track', 'oneway': 'yes', 'tunnel': '1' }) eq_(tagfilter({ 'name': 'foo', 'place': 'village', 'highway': 'track' }), { 'name': 'foo', 'highway': 'track' }) eq_( tagfilter({ 'name': 'foo', 'railway': 'tram', 'highway': 'secondary' }), { 'name': 'foo', 'railway': 'tram', 'highway': 'secondary' }) # with __any__ value eq_(tagfilter({ 'name': 'foo', 'building': 'yes' }), { 'name': 'foo', 'building': 'yes' }) eq_(tagfilter({ 'name': 'foo', 'building': 'whatever' }), { 'name': 'foo', 'building': 'whatever' }) def test_tag_filter_relations(self): tag_filter_for_relations = self.tag_mapping.tag_filter_for_relations() tagfilter = lambda x: tag_filter_for_relations(x) or x eq_(tagfilter({'name': 'foo'}), {}) eq_(tagfilter({'name': 'foo', 'unknown': 'baz'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'unknown'}), {}) eq_(tagfilter({'name': 'foo', 'landuse': 'farm'}), {}) eq_( tagfilter({ 'name': 'foo', 'landuse': 'farm', 'type': 'multipolygon' }), { 'name': 'foo', 'landuse': 'farm', 'type': 'multipolygon' }) # skip multipolygon with filtered tags, otherwise tags from longest way would be used eq_( tagfilter({ 'name': 'foo', 'landuse': 'unknown', 'type': 'multipolygon' }), {}) eq_( tagfilter({ 'name': 'foo', 'landuse': 'park', 'type': 'multipolygon' }), { 'name': 'foo', 'type': 'multipolygon', 'landuse': 'park' }) eq_( tagfilter({ 'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'multipolygon' }), { 'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'multipolygon' }) # boundary relation for boundary eq_( tagfilter({ 'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'boundary' }), { 'name': 'foo', 'landuse': 'farm', 'boundary': 'administrative', 'type': 'boundary' }) # boundary relation for non boundary eq_(tagfilter({ 'name': 'foo', 'landuse': 'farm', 'type': 'boundary' }), {}) # skip boundary with filtered tags, otherwise tags from longest way would be used eq_( tagfilter({ 'name': 'foo', 'boundary': 'unknown', 'type': 'boundary' }), {}) eq_( tagfilter({ 'name': 'foo', 'boundary': 'administrative', 'type': 'boundary' }), { 'name': 'foo', 'boundary': 'administrative', 'type': 'boundary' }) def test_mapping_for_nodes(self): for_nodes = self.tag_mapping.for_nodes eq_mapping(for_nodes({'unknown': 'baz'}), []) eq_mapping(for_nodes({'place': 'unknown'}), []) eq_mapping(for_nodes({'place': 'city'}), [(('place', 'city'), ('places', ))]) eq_mapping(for_nodes({ 'place': 'city', 'highway': 'unknown' }), [(('place', 'city'), ('places', ))]) eq_mapping(for_nodes({ 'place': 'city', 'highway': 'bus_stop' }), [(('place', 'city'), ('places', )), (('highway', 'bus_stop'), ('transport_points', ))]) def test_mapping_for_ways(self): for_ways = self.tag_mapping.for_ways eq_mapping(for_ways({'unknown': 'baz'}), []) eq_mapping(for_ways({'highway': 'unknown'}), []) eq_mapping(for_ways({'highway': 'track'}), [(('highway', 'track'), ('minorroads', ))]) eq_mapping(for_ways({ 'highway': 'secondary', 'railway': 'tram' }), [(('railway', 'tram'), ('railways', )), (('highway', 'secondary'), ('mainroads', ))]) eq_mapping(for_ways({'highway': 'footway'}), [(('highway', 'footway'), ('minorroads', )), (('highway', 'footway'), ('landusages', ))]) eq_mapping(for_ways({ 'highway': 'footway', 'landuse': 'park' }), [(('highway', 'footway'), ('minorroads', )), (('landuse', 'park'), ('landusages', ))]) def test_mapping_for_relation(self): for_relations = self.tag_mapping.for_relations eq_mapping(for_relations({'unknown': 'baz'}), []) eq_mapping(for_relations({'landuse': 'unknown'}), []) eq_mapping(for_relations({'landuse': 'farm'}), [(('landuse', 'farm'), ('landusages', ))]) eq_mapping(for_relations({ 'landuse': 'farm', 'highway': 'secondary' }), [(('landuse', 'farm'), ('landusages', ))]) eq_mapping(for_relations({ 'landuse': 'farm', 'aeroway': 'apron' }), [(('aeroway', 'apron'), ('transport_areas', )), (('landuse', 'farm'), ('landusages', ))]) eq_mapping( for_relations({ 'boundary': 'administrative', 'admin_level': '8' }), [(('boundary', 'administrative'), ('admin', ))]) def test_multiple_mappings(self): roads = LineStrings(name='roads', mapping={ 'highway': ('secondary', ), 'railway': ('tram', ), }) tag_mapping = TagMapper([roads]) for_ways = tag_mapping.for_ways eq_mapping(for_ways({'unknown': 'baz'}), []) eq_mapping(for_ways({'highway': 'unknown'}), []) eq_mapping(for_ways({'highway': 'secondary'}), [(('highway', 'secondary'), ('roads', ))]) eq_mapping(for_ways({ 'highway': 'secondary', 'railway': 'tram' }), [(('railway', 'tram'), ('roads', )), (('highway', 'secondary'), ('roads', ))])
def main(argv=None): setproctitle('imposm: main') usage = '%prog [options] [input]...' parser = optparse.OptionParser(usage=usage, add_help_option=False, version="%prog " + __version__) parser.add_option('--help', dest='help', action='store_true', default=False, help='show this help message and exit') parser.add_option('--debug', action='store_true', default=False, help='show debug information') parser.add_option('--quiet', action='store_true', default=False, help='only print progress every 60 seconds') parser.add_option('-m', '--mapping-file', dest='mapping_file', metavar='<file>') parser.add_option('-h', '--host', dest='host', metavar='<host>') parser.add_option('-p', '--port', dest='port', metavar='<port>') parser.add_option('-d', '--database', dest='db', metavar='<dbname>') parser.add_option('-U', '--user', dest='user', metavar='<user>') parser.add_option('--proj', dest='proj', metavar='EPSG:900913') parser.add_option('--connection', dest='connection', help="connection string like postgis://user:pass@host:port/database," " this overwrites the -h/-p/-d/-U options") parser.add_option('-c', '--concurrency', dest='concurrency', metavar='N', type='int', default=n_cpu) parser.add_option('--merge-cache', dest='merge_cache', default=False, action='store_true') parser.add_option('--overwrite-cache', dest='overwrite_cache', default=False, action='store_true') parser.add_option('--cache-dir', dest='cache_dir', default='.', help="path where node/ways/relations should be cached [current working dir]") parser.add_option('--table-prefix', dest='table_prefix', default=None, metavar='osm_new_', help='prefix for imported tables') parser.add_option('--table-prefix-production', dest='table_prefix_production', default='osm_', metavar='osm_', help='prefix for production tables') parser.add_option('--table-prefix-backup', dest='table_prefix_backup', default='osm_old_', metavar='osm_old_', help='prefix for backup tables') parser.add_option('--read', dest='read', default=False, action='store_true') parser.add_option('--write', dest='write', default=False, action='store_true') parser.add_option('--optimize', dest='optimize', default=False, action='store_true') parser.add_option('--deploy-production-tables', dest='deploy_tables', default=False, action='store_true', help='remove backup tables, move production tables ' 'to backup tables and move import tables to production tables') parser.add_option('--recover-production-tables', dest='recover_tables', default=False, action='store_true', help='move production tables to import tables and' 'move backup tables to production tables') parser.add_option('--remove-backup-tables', dest='remove_backup_tables', default=False, action='store_true') parser.add_option('-n', '--dry-run', dest='dry_run', default=False, action='store_true') parser.add_option('--limit-to', dest='limit_to', metavar='file', help='limit imported geometries to (multi)polygons in EPSG:4326') (options, args) = parser.parse_args(argv) setup_logging(debug=options.debug) if (argv and len(argv) == 0) or (not argv and len(sys.argv) == 1): options.help = True if not any([options.read, options.write, options.optimize, options.deploy_tables, options.recover_tables, options.remove_backup_tables]): options.help = True if options.help: parser.print_help() sys.exit(1) if options.quiet: logger = imposm.util.QuietProgressLog logger_parser = imposm.util.QuietParserProgress else: logger = imposm.util.ProgressLog logger_parser = imposm.util.ParserProgress if options.proj: if ':' not in options.proj: print 'ERROR: --proj should be in EPSG:00000 format' sys.exit(1) # check proj if meter_to_mapunit needs to do anything if options.proj.lower() == 'epsg:4326': imposm.mapping.import_srs_is_geographic = True mapping_file = os.path.join(os.path.dirname(__file__), 'defaultmapping.py') if options.mapping_file: print 'loading %s as mapping' % options.mapping_file mapping_file = options.mapping_file polygon = None if options.limit_to: logger.message('## reading --limit-to %s' % options.limit_to) polygon_timer = imposm.util.Timer('reading', logger) polygon = load_geom(options.limit_to) polygon_timer.stop() if polygon is None: print 'ERROR: No valid polygon/multipolygon found' sys.exit(1) mappings = {} execfile(mapping_file, mappings) tag_mapping = TagMapper([m for n, m in mappings.iteritems() if isinstance(m, imposm.mapping.Mapping)], limit_to=polygon) if 'IMPOSM_MULTIPOLYGON_REPORT' in os.environ: imposm.config.imposm_multipolygon_report = float(os.environ['IMPOSM_MULTIPOLYGON_REPORT']) if 'IMPOSM_MULTIPOLYGON_MAX_RING' in os.environ: imposm.config.imposm_multipolygon_max_ring = int(os.environ['IMPOSM_MULTIPOLYGON_MAX_RING']) if options.table_prefix: options.table_prefix = options.table_prefix.rstrip('_') + '_' if options.table_prefix_production: options.table_prefix_production = options.table_prefix_production.rstrip('_') + '_' if options.table_prefix_backup: options.table_prefix_backup = options.table_prefix_backup.rstrip('_') + '_' if (options.write or options.optimize or options.deploy_tables or options.remove_backup_tables or options.recover_tables): db_conf = mappings['db_conf'] if options.table_prefix: db_conf.prefix = options.table_prefix else: options.table_prefix = db_conf.prefix.rstrip('_') + '_' if options.connection: from imposm.db.config import db_conf_from_string db_conf = db_conf_from_string(options.connection, db_conf) else: db_conf.host = options.host or db_conf.host db_conf.port = options.port or getattr(db_conf, 'port', None) #backw. compat if not options.db: parser.error('-d/--database is required for this mode') db_conf.db = options.db or db_conf.db db_conf.user = options.user or db_conf.user if options.user: from getpass import getpass db_conf.password = getpass('password for %(user)s at %(host)s:' % db_conf) if options.proj: db_conf.proj = options.proj imposm_timer = imposm.util.Timer('imposm', logger) if options.read: if not options.merge_cache: cache_files = glob.glob(os.path.join(options.cache_dir, 'imposm_*.cache')) if cache_files: if not options.overwrite_cache: print ( "ERROR: found existing cache files in '%s'. " 'Remove --read option to use the existing cache ' 'or use --overwrite-cache or --merge-cache to ' 'overwrite or merge it.' % os.path.abspath(options.cache_dir) ) sys.exit(2) for cache_file in cache_files: os.unlink(cache_file) cache = OSMCache(options.cache_dir) if options.read: read_timer = imposm.util.Timer('reading', logger) if not args: print "no file(s) supplied" sys.exit(2) if options.write: err = check_connection(db_conf) if err: logger.message("ERROR: unable to connect to database. Check your DB settings.\n{0}".format(err)) sys.exit(2) reader = ImposmReader(tag_mapping, cache=cache, merge=options.merge_cache, pool_size=options.concurrency, logger=logger_parser) reader.estimated_coords = imposm.util.estimate_records(args) for arg in args: logger.message('## reading %s' % arg) reader.read(arg) read_timer.stop() if options.write: db = DB(db_conf) write_timer = imposm.util.Timer('writing', logger) logger.message('## dropping/creating tables') if not options.dry_run: db.create_tables(tag_mapping.mappings) logger.message('## writing data') # create views so we can access the table during the insert, ignore # errors for missing tables (i.e. generalized tables) if not options.dry_run: db.create_views(mappings, ignore_errors=True) db.commit() writer = ImposmWriter(tag_mapping, db, cache=cache, pool_size=options.concurrency, logger=logger, dry_run=options.dry_run) writer.relations() writer.ways() writer.nodes() if not options.dry_run: db = DB(db_conf) logger.message('## creating generalized tables') generalized_timer = imposm.util.Timer('generalizing tables', logger) db.create_generalized_tables(mappings) generalized_timer.stop() logger.message('## creating union views') view_timer = imposm.util.Timer('creating views', logger) db.create_views(mappings) view_timer.stop() logger.message('## creating geometry indexes') index_timer = imposm.util.Timer('creating indexes', logger) db.post_insert(mappings); index_timer.stop() logger.message('## post-processing tables') valid_timer = imposm.util.Timer('post-processing tables', logger) db.postprocess_tables(mappings) valid_timer.stop() db.commit() write_timer.stop() if options.optimize: db = DB(db_conf) optimize_timer = imposm.util.Timer('optimizing', logger) logger.message('## optimizing tables') db.optimize(mappings) optimize_timer.stop() if options.recover_tables: assert not options.deploy_tables, ('cannot swap and recover production ' 'tables at the same time') options.table_prefix, options.table_prefix_backup = \ options.table_prefix_backup, options.table_prefix if options.deploy_tables or options.recover_tables: db = DB(db_conf) db.swap_tables(options.table_prefix, options.table_prefix_production, options.table_prefix_backup) db.remove_views(options.table_prefix) db.db_conf.prefix = options.table_prefix_production db.create_views(mappings) db.commit() if options.remove_backup_tables: db = DB(db_conf) db.remove_tables(options.table_prefix_backup) db.commit() imposm_timer.stop()