imposm-2.6.0/0000755000076500000240000000000012454222732012747 5ustar oltstaff00000000000000imposm-2.6.0/CHANGES0000644000076500000240000000564612454213025013750 0ustar oltstaff00000000000000Changelog --------- 2.6.0 2015-01-10 ~~~~~~~~~~~~~~~~ - improve load performance of large limit-to geometries - check connection before reading and fail if unable to connect - new BoundaryPolygons mapping class that keeps inserted ways - quote column names when generalizing table - only skip import of polygons if way was inserted as multipolygon - only look for tables/views/indexes with schema=public when rotating tables - updated generated code for internal cache - minor fixes 2.5.0 2012-12-06 ~~~~~~~~~~~~~~~~ - PostGIS 2 support - new --limit-to option to limit imports to polygons - added --quiet option that only logs progress once per minute - add StringIndex and Index mappings for PostgreSQL - always drop tables _and_ views with same name before creating new table/view. allows to change mappings from views to tables and vice versa. - internal refactoring to make support for non SQL databases easier 2.4.0 2012-03-30 ~~~~~~~~~~~~~~~~ - new Class and Type field types - add support to disable automatic ``type`` column - new --connection option - support for PostGIS Trigram indices - do not try to simplify empty geometries - limit progress logging to 5 times per second - use SERIAL as primary key to support multiple features with the same OSM ID - new optional splitting of long line strings - use BIGINT for OSM ID in Postgres to support 64bit OSM IDs 2.3.2 2011-09-05 ~~~~~~~~~~~~~~~~ - fixed --table-prefix - add --debug option for more verbose output - fixed way merging - fixed default_name_fields for UnionViews - improved (contains) relation builder 2.3.1 2011-07-05 ~~~~~~~~~~~~~~~~ - DROP views instead of REPLACE to prevent errors when columns changed 2.3.0 2011-07-05 ~~~~~~~~~~~~~~~~ - new PseudoArea field type - new Name and LocalizedName field type - update SRS in GeneralizedTables and UnionTables - new waterareas_gen0|1 in default style - new area field in landusages table - new meter_to_mapunit function to use same mapping for EPSG:4326 and projected SRS 2.2.0 2011-06-01 ~~~~~~~~~~~~~~~~ - support for Shapely speedups (>=1.2.10) - new --port option for PostgreSQL port - reduced size of nodes cache by ~40% - store inserted ways in extra cache - support for relations type=boundary - new faster relation builder that supports relations with >1000 rings - set import options in mapping file - import_partial_relations=True/False - relation_builder=contains(new)/union(old) - imposm_multipolygon_report=60(seconds) - imposm_multipolygon_max_ring=0 2.1.3 2011-04-19 ~~~~~~~~~~~~~~~~ - support for colons and other special chars in field and table names (e.g. de:name) 2.1.2 2011-04-13 ~~~~~~~~~~~~~~~~ - make it work on 32bit systems 2.1.1 2011-04-12 ~~~~~~~~~~~~~~~~ - new ``--proj`` option to change DB projection from EPSG:900913 - abort if there are existing cache files - new ``--merge-cache`` and ``--overwrite-cache`` options 2.1.0 2011-03-29 ~~~~~~~~~~~~~~~~ - first open source release imposm-2.6.0/imposm/0000755000076500000240000000000012454222732014253 5ustar oltstaff00000000000000imposm-2.6.0/imposm/900913.sql0000644000076500000240000000132611766043214015544 0ustar oltstaff00000000000000INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, srtext, proj4text)VALUES (900913,'EPSG',900913,'PROJCS["WGS84 / Simple Mercator",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS_1984", 6378137.0, 298.257223563]],PRIMEM["Greenwich", 0.0],UNIT["degree", 0.017453292519943295],AXIS["Longitude", EAST],AXIS["Latitude", NORTH]],PROJECTION["Mercator_1SP_Google"],PARAMETER["latitude_of_origin", 0.0],PARAMETER["central_meridian", 0.0],PARAMETER["scale_factor", 1.0],PARAMETER["false_easting", 0.0],PARAMETER["false_northing", 0.0],UNIT["m", 1.0],AXIS["x", EAST],AXIS["y", NORTH],AUTHORITY["EPSG","900913"]]','+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs'); imposm-2.6.0/imposm/__init__.py0000644000076500000240000000006711766043214016370 0ustar oltstaff00000000000000__import__('pkg_resources').declare_namespace(__name__)imposm-2.6.0/imposm/app.py0000644000076500000240000003137212266246437015424 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import with_statement import glob import sys import os import optparse import logging import multiprocessing from imposm.util import setproctitle try: import shapely.speedups if shapely.speedups.available: print 'Enabling Shapely speedups.' shapely.speedups.enable() except ImportError: try: import shapely_speedups print 'Patching Shapely.' shapely_speedups.patch_shapely() except ImportError: pass import imposm.config import imposm.mapping import imposm.util import imposm.version from imposm.writer import ImposmWriter from imposm.db.config import DB, check_connection from imposm.cache import OSMCache from imposm.reader import ImposmReader from imposm.mapping import TagMapper from imposm.geom import load_geom try: n_cpu = multiprocessing.cpu_count() except NotImplementedError: n_cpu = 2 def setup_logging(debug=False): imposm_log = logging.getLogger('imposm') imposm_log.setLevel(logging.DEBUG if debug else logging.INFO) ch = logging.StreamHandler(sys.stdout) ch.setLevel(logging.DEBUG) formatter = logging.Formatter( "[%(asctime)s] %(name)s - %(levelname)s - %(message)s") ch.setFormatter(formatter) imposm_log.addHandler(ch) __version__ = imposm.version.__version__ 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='') parser.add_option('-h', '--host', dest='host', metavar='') parser.add_option('-p', '--port', dest='port', metavar='') parser.add_option('-d', '--database', dest='db', metavar='') parser.add_option('-U', '--user', dest='user', metavar='') 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() if __name__ == '__main__': main() imposm-2.6.0/imposm/base.py0000644000076500000240000000627711766043214015554 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import with_statement import itertools from imposm.merge import multimerge __all__ = [ 'Node', 'Way', 'Relation', ] class Node(object): def __init__(self, osm_id, tags, coord): self.osm_id = osm_id self.tags = tags self.coord = coord def __repr__(self): return 'Node(%r, %r, %r)' % (self.osm_id, self.tags, self.coord) def merge(self, tags, coord): pass def to_tuple(self): return self.osm_id, self.tags, self.coord class Way(object): def __init__(self, osm_id, tags, refs, inserted=False): self.osm_id = osm_id self.tags = tags self.refs = refs self.partial_refs = None if refs and isinstance(refs[0], list): self.refs = refs[0] self.partial_refs = refs self.inserted = inserted def __repr__(self): return 'Way(%r, %r, %r, inserted=%r)' % (self.osm_id, self.tags, self.refs, self.inserted) def merge(self, tags, refs): self.tags.update(tags) if self.refs != refs: if self.partial_refs: merge_refs = [] merge_refs.extend(self.partial_refs) else: merge_refs = [self.refs] merge_refs.append(refs) result = multimerge(merge_refs) if result is None: self.partial_refs = merge_refs else: self.refs = result self.partial_refs = None def to_tuple(self): return self.osm_id, self.tags, self.refs class Relation(object): def __init__(self, osm_id, tags, members): self.osm_id = osm_id self.tags = tags self.members = members def merge(self, tags, members): self.tags.update(tags) if self.members != members: self.members = merge_relation_members(self.members, members) def to_tuple(self): return self.osm_id, self.tags, self.members def merge_relation_members(a, b): """ concatenate two lists of members, removing duplicates, retaining order """ combined = [] added_ids = set() for m in itertools.chain(a, b): if m[0] not in added_ids: combined.append(m) added_ids.add(m[0]) return combined class OSMElem(object): __slots__ = 'osm_id name coords cls type tags geom'.split() def __init__(self, osm_id, coords, type, tags): self.osm_id = osm_id self.name = tags.get('name') self.coords = coords self.cls = type[0] self.type = type[1] self.tags = tags self.geom = Noneimposm-2.6.0/imposm/cache/0000755000076500000240000000000012454222732015316 5ustar oltstaff00000000000000imposm-2.6.0/imposm/cache/__init__.py0000644000076500000240000000006211766043214017426 0ustar oltstaff00000000000000from . osm import OSMCache __all__ = ['OSMCache']imposm-2.6.0/imposm/cache/internal.cc0000644000076500000240000010045212454213016017436 0ustar oltstaff00000000000000// -*- C++ -*- #include #include #include #include "structmember.h" #include "internal.pb.h" #include #include static PyObject * fastpb_convert5(::google::protobuf::int32 value) { return PyLong_FromLong(value); } static PyObject * fastpb_convert3(::google::protobuf::int64 value) { return PyLong_FromLongLong(value); } static PyObject * fastpb_convert18(::google::protobuf::int64 value) { return PyLong_FromLongLong(value); } static PyObject * fastpb_convert17(::google::protobuf::int32 value) { return PyLong_FromLong(value); } static PyObject * fastpb_convert13(::google::protobuf::uint32 value) { return PyLong_FromUnsignedLong(value); } static PyObject * fastpb_convert7(::google::protobuf::int32 value) { return PyLong_FromLong(value); } static PyObject * fastpb_convert4(::google::protobuf::uint64 value) { return PyLong_FromUnsignedLong(value); } static PyObject * fastpb_convert1(double value) { return PyFloat_FromDouble(value); } static PyObject * fastpb_convert2(float value) { return PyFloat_FromDouble(value); } static PyObject * fastpb_convert9(const ::std::string &value) { return PyUnicode_Decode(value.data(), value.length(), "utf-8", NULL); } static PyObject * fastpb_convert12(const ::std::string &value) { return PyString_FromStringAndSize(value.data(), value.length()); } static PyObject * fastpb_convert8(bool value) { return PyBool_FromLong(value ? 1 : 0); } static PyObject * fastpb_convert14(int value) { // TODO(robbyw): Check EnumName_IsValid(value) return PyInt_FromLong(value); } // Lets try not to pollute the global namespace namespace { // Forward-declaration for recursive structures extern PyTypeObject DeltaCoordsType; typedef struct { PyObject_HEAD imposm::cache::internal::DeltaCoords *protobuf; } DeltaCoords; void DeltaCoords_dealloc(DeltaCoords* self) { delete self->protobuf; self->ob_type->tp_free((PyObject*)self); } PyObject * DeltaCoords_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { DeltaCoords *self; self = (DeltaCoords *)type->tp_alloc(type, 0); self->protobuf = new imposm::cache::internal::DeltaCoords(); return (PyObject *)self; } PyObject * DeltaCoords_DebugString(DeltaCoords* self) { std::string result; Py_BEGIN_ALLOW_THREADS result = self->protobuf->Utf8DebugString(); Py_END_ALLOW_THREADS return PyUnicode_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaCoords_SerializeToString(DeltaCoords* self) { std::string result; Py_BEGIN_ALLOW_THREADS self->protobuf->SerializeToString(&result); Py_END_ALLOW_THREADS return PyString_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaCoords_SerializeMany(void *nothing, PyObject *values) { std::string result; google::protobuf::io::ZeroCopyOutputStream* output = new google::protobuf::io::StringOutputStream(&result); google::protobuf::io::CodedOutputStream* outputStream = new google::protobuf::io::CodedOutputStream(output); PyObject *sequence = PySequence_Fast(values, "The values to serialize must be a sequence."); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { DeltaCoords *value = (DeltaCoords *)PySequence_Fast_GET_ITEM(sequence, i); Py_BEGIN_ALLOW_THREADS outputStream->WriteVarint32(value->protobuf->ByteSize()); value->protobuf->SerializeToCodedStream(outputStream); Py_END_ALLOW_THREADS } Py_XDECREF(sequence); delete outputStream; delete output; return PyString_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaCoords_ParseFromString(DeltaCoords* self, PyObject *value) { std::string serialized(PyString_AsString(value), PyString_Size(value)); Py_BEGIN_ALLOW_THREADS self->protobuf->ParseFromString(serialized); Py_END_ALLOW_THREADS Py_RETURN_NONE; } PyObject * DeltaCoords_ParseFromLongString(DeltaCoords* self, PyObject *value) { google::protobuf::io::ZeroCopyInputStream* input = new google::protobuf::io::ArrayInputStream(PyString_AsString(value), PyString_Size(value)); google::protobuf::io::CodedInputStream* inputStream = new google::protobuf::io::CodedInputStream(input); inputStream->SetTotalBytesLimit(512 * 1024 * 1024, 512 * 1024 * 1024); Py_BEGIN_ALLOW_THREADS self->protobuf->ParseFromCodedStream(inputStream); Py_END_ALLOW_THREADS delete inputStream; delete input; Py_RETURN_NONE; } PyObject * DeltaCoords_ParseMany(void* nothing, PyObject *args) { PyObject *value; PyObject *callback; int fail = 0; if (!PyArg_ParseTuple(args, "OO", &value, &callback)) { return NULL; } google::protobuf::io::ZeroCopyInputStream* input = new google::protobuf::io::ArrayInputStream(PyString_AsString(value), PyString_Size(value)); google::protobuf::io::CodedInputStream* inputStream = new google::protobuf::io::CodedInputStream(input); inputStream->SetTotalBytesLimit(512 * 1024 * 1024, 512 * 1024 * 1024); google::protobuf::uint32 bytes; PyObject *single = NULL; while (inputStream->ReadVarint32(&bytes)) { google::protobuf::io::CodedInputStream::Limit messageLimit = inputStream->PushLimit(bytes); if (single == NULL) { single = DeltaCoords_new(&DeltaCoordsType, NULL, NULL); } Py_BEGIN_ALLOW_THREADS ((DeltaCoords *)single)->protobuf->ParseFromCodedStream(inputStream); Py_END_ALLOW_THREADS inputStream->PopLimit(messageLimit); PyObject *result = PyObject_CallFunctionObjArgs(callback, single, NULL); if (result == NULL) { fail = 1; break; }; if (single->ob_refcnt != 1) { // If the callback saved a reference to the item, don't re-use it. Py_XDECREF(single); single = NULL; } } if (single != NULL) { Py_XDECREF(single); } delete inputStream; delete input; if (fail) { return NULL; } else { Py_RETURN_NONE; } } PyObject * DeltaCoords_getids(DeltaCoords *self, void *closure) { int len = self->protobuf->ids_size(); PyObject *tuple = PyTuple_New(len); for (int i = 0; i < len; ++i) { PyObject *value = fastpb_convert18( self->protobuf->ids(i)); if (!value) { return NULL; } PyTuple_SetItem(tuple, i, value); } return tuple; } int DeltaCoords_setids(DeltaCoords *self, PyObject *input, void *closure) { if (input == NULL || input == Py_None) { self->protobuf->clear_ids(); return 0; } if (PyString_Check(input)) { PyErr_SetString(PyExc_TypeError, "The ids attribute value must be a sequence"); return -1; } PyObject *sequence = PySequence_Fast(input, "The ids attribute value must be a sequence"); self->protobuf->clear_ids(); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { PyObject *value = PySequence_Fast_GET_ITEM(sequence, i); ::google::protobuf::int64 protoValue; // int64 if (PyInt_Check(value)) { protoValue = PyInt_AsLong(value); } else if (PyLong_Check(value)) { protoValue = PyLong_AsLongLong(value); } else { PyErr_SetString(PyExc_TypeError, "The ids attribute value must be an integer"); return -1; } self->protobuf->add_ids(protoValue); } Py_XDECREF(sequence); return 0; } PyObject * DeltaCoords_getlats(DeltaCoords *self, void *closure) { int len = self->protobuf->lats_size(); PyObject *tuple = PyTuple_New(len); for (int i = 0; i < len; ++i) { PyObject *value = fastpb_convert18( self->protobuf->lats(i)); if (!value) { return NULL; } PyTuple_SetItem(tuple, i, value); } return tuple; } int DeltaCoords_setlats(DeltaCoords *self, PyObject *input, void *closure) { if (input == NULL || input == Py_None) { self->protobuf->clear_lats(); return 0; } if (PyString_Check(input)) { PyErr_SetString(PyExc_TypeError, "The lats attribute value must be a sequence"); return -1; } PyObject *sequence = PySequence_Fast(input, "The lats attribute value must be a sequence"); self->protobuf->clear_lats(); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { PyObject *value = PySequence_Fast_GET_ITEM(sequence, i); ::google::protobuf::int64 protoValue; // int64 if (PyInt_Check(value)) { protoValue = PyInt_AsLong(value); } else if (PyLong_Check(value)) { protoValue = PyLong_AsLongLong(value); } else { PyErr_SetString(PyExc_TypeError, "The lats attribute value must be an integer"); return -1; } self->protobuf->add_lats(protoValue); } Py_XDECREF(sequence); return 0; } PyObject * DeltaCoords_getlons(DeltaCoords *self, void *closure) { int len = self->protobuf->lons_size(); PyObject *tuple = PyTuple_New(len); for (int i = 0; i < len; ++i) { PyObject *value = fastpb_convert18( self->protobuf->lons(i)); if (!value) { return NULL; } PyTuple_SetItem(tuple, i, value); } return tuple; } int DeltaCoords_setlons(DeltaCoords *self, PyObject *input, void *closure) { if (input == NULL || input == Py_None) { self->protobuf->clear_lons(); return 0; } if (PyString_Check(input)) { PyErr_SetString(PyExc_TypeError, "The lons attribute value must be a sequence"); return -1; } PyObject *sequence = PySequence_Fast(input, "The lons attribute value must be a sequence"); self->protobuf->clear_lons(); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { PyObject *value = PySequence_Fast_GET_ITEM(sequence, i); ::google::protobuf::int64 protoValue; // int64 if (PyInt_Check(value)) { protoValue = PyInt_AsLong(value); } else if (PyLong_Check(value)) { protoValue = PyLong_AsLongLong(value); } else { PyErr_SetString(PyExc_TypeError, "The lons attribute value must be an integer"); return -1; } self->protobuf->add_lons(protoValue); } Py_XDECREF(sequence); return 0; } int DeltaCoords_init(DeltaCoords *self, PyObject *args, PyObject *kwds) { PyObject *ids = NULL; PyObject *lats = NULL; PyObject *lons = NULL; static char *kwlist[] = { (char *) "ids", (char *) "lats", (char *) "lons", NULL }; if (! PyArg_ParseTupleAndKeywords( args, kwds, "|OOO", kwlist, &ids,&lats,&lons)) return -1; if (ids) { if (DeltaCoords_setids(self, ids, NULL) < 0) { return -1; } } if (lats) { if (DeltaCoords_setlats(self, lats, NULL) < 0) { return -1; } } if (lons) { if (DeltaCoords_setlons(self, lons, NULL) < 0) { return -1; } } return 0; } PyObject * DeltaCoords_richcompare(PyObject *self, PyObject *other, int op) { PyObject *result = NULL; if (!PyType_IsSubtype(other->ob_type, &DeltaCoordsType)) { result = Py_NotImplemented; } else { // This is not a particularly efficient implementation since it never short circuits, but it's better // than nothing. It should probably only be used for tests. DeltaCoords *selfValue = (DeltaCoords *)self; DeltaCoords *otherValue = (DeltaCoords *)other; std::string selfSerialized; std::string otherSerialized; Py_BEGIN_ALLOW_THREADS selfValue->protobuf->SerializeToString(&selfSerialized); otherValue->protobuf->SerializeToString(&otherSerialized); Py_END_ALLOW_THREADS int cmp = selfSerialized.compare(otherSerialized); bool value = false; switch (op) { case Py_LT: value = cmp < 0; break; case Py_LE: value = cmp <= 0; break; case Py_EQ: value = cmp == 0; break; case Py_NE: value = cmp != 0; break; case Py_GT: value = cmp > 0; break; case Py_GE: value = cmp >= 0; break; } result = value ? Py_True : Py_False; } Py_XINCREF(result); return result; } static PyObject * DeltaCoords_repr(PyObject *selfObject) { DeltaCoords *self = (DeltaCoords *)selfObject; PyObject *member; PyObject *memberRepr; std::stringstream result; result << "DeltaCoords("; result << "ids="; member = DeltaCoords_getids(self, NULL); memberRepr = PyObject_Repr(member); result << PyString_AsString(memberRepr); Py_XDECREF(memberRepr); Py_XDECREF(member); result << ", "; result << "lats="; member = DeltaCoords_getlats(self, NULL); memberRepr = PyObject_Repr(member); result << PyString_AsString(memberRepr); Py_XDECREF(memberRepr); Py_XDECREF(member); result << ", "; result << "lons="; member = DeltaCoords_getlons(self, NULL); memberRepr = PyObject_Repr(member); result << PyString_AsString(memberRepr); Py_XDECREF(memberRepr); Py_XDECREF(member); result << ")"; std::string resultString = result.str(); return PyUnicode_Decode(resultString.data(), resultString.length(), "utf-8", NULL); } PyMemberDef DeltaCoords_members[] = { {NULL} // Sentinel }; PyGetSetDef DeltaCoords_getsetters[] = { {(char *)"ids", (getter)DeltaCoords_getids, (setter)DeltaCoords_setids, (char *)"", NULL}, {(char *)"lats", (getter)DeltaCoords_getlats, (setter)DeltaCoords_setlats, (char *)"", NULL}, {(char *)"lons", (getter)DeltaCoords_getlons, (setter)DeltaCoords_setlons, (char *)"", NULL}, {NULL} // Sentinel }; PyMethodDef DeltaCoords_methods[] = { {"DebugString", (PyCFunction)DeltaCoords_DebugString, METH_NOARGS, "Generates a human readable form of this message, useful for debugging and other purposes." }, {"SerializeToString", (PyCFunction)DeltaCoords_SerializeToString, METH_NOARGS, "Serializes the protocol buffer to a string." }, {"SerializeMany", (PyCFunction)DeltaCoords_SerializeMany, METH_O | METH_CLASS, "Serializes a sequence of protocol buffers to a string." }, {"ParseFromString", (PyCFunction)DeltaCoords_ParseFromString, METH_O, "Parses the protocol buffer from a string." }, {"ParseFromLongString", (PyCFunction)DeltaCoords_ParseFromLongString, METH_O, "Parses the protocol buffer from a string as large as 512MB." }, {"ParseMany", (PyCFunction)DeltaCoords_ParseMany, METH_VARARGS | METH_CLASS, "Parses many protocol buffers of this type from a string." }, {NULL} // Sentinel }; PyTypeObject DeltaCoordsType = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "imposm.cache.internal.DeltaCoords", /*tp_name*/ sizeof(DeltaCoords), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor)DeltaCoords_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ DeltaCoords_repr, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash */ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_RICHCOMPARE, /*tp_flags*/ "DeltaCoords objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ DeltaCoords_richcompare, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ DeltaCoords_methods, /* tp_methods */ DeltaCoords_members, /* tp_members */ DeltaCoords_getsetters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc)DeltaCoords_init, /* tp_init */ 0, /* tp_alloc */ DeltaCoords_new, /* tp_new */ }; } // Lets try not to pollute the global namespace namespace { // Forward-declaration for recursive structures extern PyTypeObject DeltaListType; typedef struct { PyObject_HEAD imposm::cache::internal::DeltaList *protobuf; } DeltaList; void DeltaList_dealloc(DeltaList* self) { delete self->protobuf; self->ob_type->tp_free((PyObject*)self); } PyObject * DeltaList_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { DeltaList *self; self = (DeltaList *)type->tp_alloc(type, 0); self->protobuf = new imposm::cache::internal::DeltaList(); return (PyObject *)self; } PyObject * DeltaList_DebugString(DeltaList* self) { std::string result; Py_BEGIN_ALLOW_THREADS result = self->protobuf->Utf8DebugString(); Py_END_ALLOW_THREADS return PyUnicode_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaList_SerializeToString(DeltaList* self) { std::string result; Py_BEGIN_ALLOW_THREADS self->protobuf->SerializeToString(&result); Py_END_ALLOW_THREADS return PyString_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaList_SerializeMany(void *nothing, PyObject *values) { std::string result; google::protobuf::io::ZeroCopyOutputStream* output = new google::protobuf::io::StringOutputStream(&result); google::protobuf::io::CodedOutputStream* outputStream = new google::protobuf::io::CodedOutputStream(output); PyObject *sequence = PySequence_Fast(values, "The values to serialize must be a sequence."); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { DeltaList *value = (DeltaList *)PySequence_Fast_GET_ITEM(sequence, i); Py_BEGIN_ALLOW_THREADS outputStream->WriteVarint32(value->protobuf->ByteSize()); value->protobuf->SerializeToCodedStream(outputStream); Py_END_ALLOW_THREADS } Py_XDECREF(sequence); delete outputStream; delete output; return PyString_FromStringAndSize(result.data(), result.length()); } PyObject * DeltaList_ParseFromString(DeltaList* self, PyObject *value) { std::string serialized(PyString_AsString(value), PyString_Size(value)); Py_BEGIN_ALLOW_THREADS self->protobuf->ParseFromString(serialized); Py_END_ALLOW_THREADS Py_RETURN_NONE; } PyObject * DeltaList_ParseFromLongString(DeltaList* self, PyObject *value) { google::protobuf::io::ZeroCopyInputStream* input = new google::protobuf::io::ArrayInputStream(PyString_AsString(value), PyString_Size(value)); google::protobuf::io::CodedInputStream* inputStream = new google::protobuf::io::CodedInputStream(input); inputStream->SetTotalBytesLimit(512 * 1024 * 1024, 512 * 1024 * 1024); Py_BEGIN_ALLOW_THREADS self->protobuf->ParseFromCodedStream(inputStream); Py_END_ALLOW_THREADS delete inputStream; delete input; Py_RETURN_NONE; } PyObject * DeltaList_ParseMany(void* nothing, PyObject *args) { PyObject *value; PyObject *callback; int fail = 0; if (!PyArg_ParseTuple(args, "OO", &value, &callback)) { return NULL; } google::protobuf::io::ZeroCopyInputStream* input = new google::protobuf::io::ArrayInputStream(PyString_AsString(value), PyString_Size(value)); google::protobuf::io::CodedInputStream* inputStream = new google::protobuf::io::CodedInputStream(input); inputStream->SetTotalBytesLimit(512 * 1024 * 1024, 512 * 1024 * 1024); google::protobuf::uint32 bytes; PyObject *single = NULL; while (inputStream->ReadVarint32(&bytes)) { google::protobuf::io::CodedInputStream::Limit messageLimit = inputStream->PushLimit(bytes); if (single == NULL) { single = DeltaList_new(&DeltaListType, NULL, NULL); } Py_BEGIN_ALLOW_THREADS ((DeltaList *)single)->protobuf->ParseFromCodedStream(inputStream); Py_END_ALLOW_THREADS inputStream->PopLimit(messageLimit); PyObject *result = PyObject_CallFunctionObjArgs(callback, single, NULL); if (result == NULL) { fail = 1; break; }; if (single->ob_refcnt != 1) { // If the callback saved a reference to the item, don't re-use it. Py_XDECREF(single); single = NULL; } } if (single != NULL) { Py_XDECREF(single); } delete inputStream; delete input; if (fail) { return NULL; } else { Py_RETURN_NONE; } } PyObject * DeltaList_getids(DeltaList *self, void *closure) { int len = self->protobuf->ids_size(); PyObject *tuple = PyTuple_New(len); for (int i = 0; i < len; ++i) { PyObject *value = fastpb_convert18( self->protobuf->ids(i)); if (!value) { return NULL; } PyTuple_SetItem(tuple, i, value); } return tuple; } int DeltaList_setids(DeltaList *self, PyObject *input, void *closure) { if (input == NULL || input == Py_None) { self->protobuf->clear_ids(); return 0; } if (PyString_Check(input)) { PyErr_SetString(PyExc_TypeError, "The ids attribute value must be a sequence"); return -1; } PyObject *sequence = PySequence_Fast(input, "The ids attribute value must be a sequence"); self->protobuf->clear_ids(); for (Py_ssize_t i = 0, len = PySequence_Length(sequence); i < len; ++i) { PyObject *value = PySequence_Fast_GET_ITEM(sequence, i); ::google::protobuf::int64 protoValue; // int64 if (PyInt_Check(value)) { protoValue = PyInt_AsLong(value); } else if (PyLong_Check(value)) { protoValue = PyLong_AsLongLong(value); } else { PyErr_SetString(PyExc_TypeError, "The ids attribute value must be an integer"); return -1; } self->protobuf->add_ids(protoValue); } Py_XDECREF(sequence); return 0; } int DeltaList_init(DeltaList *self, PyObject *args, PyObject *kwds) { PyObject *ids = NULL; static char *kwlist[] = { (char *) "ids", NULL }; if (! PyArg_ParseTupleAndKeywords( args, kwds, "|O", kwlist, &ids)) return -1; if (ids) { if (DeltaList_setids(self, ids, NULL) < 0) { return -1; } } return 0; } PyObject * DeltaList_richcompare(PyObject *self, PyObject *other, int op) { PyObject *result = NULL; if (!PyType_IsSubtype(other->ob_type, &DeltaListType)) { result = Py_NotImplemented; } else { // This is not a particularly efficient implementation since it never short circuits, but it's better // than nothing. It should probably only be used for tests. DeltaList *selfValue = (DeltaList *)self; DeltaList *otherValue = (DeltaList *)other; std::string selfSerialized; std::string otherSerialized; Py_BEGIN_ALLOW_THREADS selfValue->protobuf->SerializeToString(&selfSerialized); otherValue->protobuf->SerializeToString(&otherSerialized); Py_END_ALLOW_THREADS int cmp = selfSerialized.compare(otherSerialized); bool value = false; switch (op) { case Py_LT: value = cmp < 0; break; case Py_LE: value = cmp <= 0; break; case Py_EQ: value = cmp == 0; break; case Py_NE: value = cmp != 0; break; case Py_GT: value = cmp > 0; break; case Py_GE: value = cmp >= 0; break; } result = value ? Py_True : Py_False; } Py_XINCREF(result); return result; } static PyObject * DeltaList_repr(PyObject *selfObject) { DeltaList *self = (DeltaList *)selfObject; PyObject *member; PyObject *memberRepr; std::stringstream result; result << "DeltaList("; result << "ids="; member = DeltaList_getids(self, NULL); memberRepr = PyObject_Repr(member); result << PyString_AsString(memberRepr); Py_XDECREF(memberRepr); Py_XDECREF(member); result << ")"; std::string resultString = result.str(); return PyUnicode_Decode(resultString.data(), resultString.length(), "utf-8", NULL); } PyMemberDef DeltaList_members[] = { {NULL} // Sentinel }; PyGetSetDef DeltaList_getsetters[] = { {(char *)"ids", (getter)DeltaList_getids, (setter)DeltaList_setids, (char *)"", NULL}, {NULL} // Sentinel }; PyMethodDef DeltaList_methods[] = { {"DebugString", (PyCFunction)DeltaList_DebugString, METH_NOARGS, "Generates a human readable form of this message, useful for debugging and other purposes." }, {"SerializeToString", (PyCFunction)DeltaList_SerializeToString, METH_NOARGS, "Serializes the protocol buffer to a string." }, {"SerializeMany", (PyCFunction)DeltaList_SerializeMany, METH_O | METH_CLASS, "Serializes a sequence of protocol buffers to a string." }, {"ParseFromString", (PyCFunction)DeltaList_ParseFromString, METH_O, "Parses the protocol buffer from a string." }, {"ParseFromLongString", (PyCFunction)DeltaList_ParseFromLongString, METH_O, "Parses the protocol buffer from a string as large as 512MB." }, {"ParseMany", (PyCFunction)DeltaList_ParseMany, METH_VARARGS | METH_CLASS, "Parses many protocol buffers of this type from a string." }, {NULL} // Sentinel }; PyTypeObject DeltaListType = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "imposm.cache.internal.DeltaList", /*tp_name*/ sizeof(DeltaList), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor)DeltaList_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ DeltaList_repr, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash */ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_RICHCOMPARE, /*tp_flags*/ "DeltaList objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ DeltaList_richcompare, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ DeltaList_methods, /* tp_methods */ DeltaList_members, /* tp_members */ DeltaList_getsetters, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ (initproc)DeltaList_init, /* tp_init */ 0, /* tp_alloc */ DeltaList_new, /* tp_new */ }; } static PyMethodDef module_methods[] = { {NULL} // Sentinel }; #ifndef PyMODINIT_FUNC // Declarations for DLL import/export. #define PyMODINIT_FUNC void #endif PyMODINIT_FUNC initinternal(void) { GOOGLE_PROTOBUF_VERIFY_VERSION; PyObject* m; if (PyType_Ready(&DeltaCoordsType) < 0) return; if (PyType_Ready(&DeltaListType) < 0) return; m = Py_InitModule3("internal", module_methods, ""); if (m == NULL) return; Py_INCREF(&DeltaCoordsType); PyModule_AddObject(m, "DeltaCoords", (PyObject *)&DeltaCoordsType); Py_INCREF(&DeltaListType); PyModule_AddObject(m, "DeltaList", (PyObject *)&DeltaListType); }imposm-2.6.0/imposm/cache/osm.py0000644000076500000240000000544211766043214016474 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import imposm.config from . tc import DeltaCoordsDB, CoordDB, NodeDB, WayDB, InsertedWayDB, RelationDB class OSMCache(object): def __init__(self, path, prefix='imposm_', suffix='.cache'): self.path = path self.prefix = prefix self.suffix = suffix self.coords_fname = os.path.join(path, prefix + 'coords' + suffix) self.nodes_fname = os.path.join(path, prefix + 'nodes' + suffix) self.ways_fname = os.path.join(path, prefix + 'ways' + suffix) self.inserted_ways_fname = os.path.join(path, prefix + 'inserted_ways' + suffix) self.relations_fname = os.path.join(path, prefix + 'relations' + suffix) self.caches = {} def close_all(self): for mode_, cache in self.caches.values(): cache.close() self.caches = {} def coords_cache(self, mode='r', estimated_records=None): if imposm.config.imposm_compact_coords_cache: coords_db = DeltaCoordsDB else: coords_db = CoordDB return self._x_cache(self.coords_fname, coords_db, mode, estimated_records) def nodes_cache(self, mode='r', estimated_records=None): return self._x_cache(self.nodes_fname, NodeDB, mode, estimated_records) def ways_cache(self, mode='r', estimated_records=None): return self._x_cache(self.ways_fname, WayDB, mode, estimated_records) def inserted_ways_cache(self, mode='r', estimated_records=None): return self._x_cache(self.inserted_ways_fname, InsertedWayDB, mode, estimated_records) def remove_inserted_way_cache(self): if os.path.exists(self.inserted_ways_fname): os.unlink(self.inserted_ways_fname) def relations_cache(self, mode='r', estimated_records=None): return self._x_cache(self.relations_fname, RelationDB, mode, estimated_records) def _x_cache(self, x, x_class, mode, estimated_records=None): if x in self.caches: current_mode, cache = self.caches[x] if current_mode == mode: return cache else: cache.close() cache = x_class(x, mode, estimated_records=estimated_records) self.caches[x] = mode, cache return cache imposm-2.6.0/imposm/cache/tc.c0000644000076500000240000205715312454213016016100 0ustar oltstaff00000000000000/* Generated by Cython 0.21.2 */ #define PY_SSIZE_T_CLEAN #ifndef CYTHON_USE_PYLONG_INTERNALS #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 0 #else #include "pyconfig.h" #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 1 #else #define CYTHON_USE_PYLONG_INTERNALS 0 #endif #endif #endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_21_2" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #if PY_MAJOR_VERSION >= 3 #define Py_TPFLAGS_CHECKTYPES 0 #define Py_TPFLAGS_HAVE_INDEX 0 #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE) #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #else #define CYTHON_PEP393_ENABLED 0 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #ifndef CYTHON_INLINE #if defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #ifdef __cplusplus template void __Pyx_call_destructor(T* x) { x->~T(); } #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #define __PYX_HAVE__imposm__cache__tc #define __PYX_HAVE_API__imposm__cache__tc #include "stdint.h" #include "marshal.h" #include "tcutil.h" #include "tcbdb.h" #ifdef _OPENMP #include #endif /* _OPENMP */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ (sizeof(type) < sizeof(Py_ssize_t)) || \ (sizeof(type) > sizeof(Py_ssize_t) && \ likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX) && \ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ v == (type)PY_SSIZE_T_MIN))) || \ (sizeof(type) == sizeof(Py_ssize_t) && \ (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s) #if PY_MAJOR_VERSION < 3 static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_COMPILING_IN_CPYTHON #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "imposm/cache/tc.pyx", }; /*--- Type declarations ---*/ struct __pyx_obj_6imposm_5cache_2tc_BDB; struct __pyx_obj_6imposm_5cache_2tc_CoordDB; struct __pyx_obj_6imposm_5cache_2tc_NodeDB; struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB; struct __pyx_obj_6imposm_5cache_2tc_RefTagDB; struct __pyx_obj_6imposm_5cache_2tc_WayDB; struct __pyx_obj_6imposm_5cache_2tc_RelationDB; struct __pyx_t_6imposm_5cache_2tc_coord; typedef struct __pyx_t_6imposm_5cache_2tc_coord __pyx_t_6imposm_5cache_2tc_coord; /* "imposm/cache/tc.pyx":75 * return ((x / COORD_FACTOR) - 180.0) * * ctypedef struct coord: # <<<<<<<<<<<<<< * uint32_t x * uint32_t y */ struct __pyx_t_6imposm_5cache_2tc_coord { uint32_t x; uint32_t y; }; /* "imposm/cache/tc.pyx":90 * } * * cdef class BDB: # <<<<<<<<<<<<<< * cdef TCBDB *db * cdef object filename */ struct __pyx_obj_6imposm_5cache_2tc_BDB { PyObject_HEAD struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB *__pyx_vtab; TCBDB *db; PyObject *filename; int _opened; BDBCUR *_cur; }; /* "imposm/cache/tc.pyx":217 * tcbdbdel(self.db) * * cdef class CoordDB(BDB): # <<<<<<<<<<<<<< * def put(self, osmid, x, y): * return self._put(osmid, x, y) */ struct __pyx_obj_6imposm_5cache_2tc_CoordDB { struct __pyx_obj_6imposm_5cache_2tc_BDB __pyx_base; }; /* "imposm/cache/tc.pyx":260 * return osmid, data * * cdef class NodeDB(BDB): # <<<<<<<<<<<<<< * def put(self, osmid, tags, pos): * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) */ struct __pyx_obj_6imposm_5cache_2tc_NodeDB { struct __pyx_obj_6imposm_5cache_2tc_BDB __pyx_base; }; /* "imposm/cache/tc.pyx":270 * return Node(osmid, data[0], data[1]) * * cdef class InsertedWayDB(BDB): # <<<<<<<<<<<<<< * def put(self, int64_t osmid): * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); */ struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB { struct __pyx_obj_6imposm_5cache_2tc_BDB __pyx_base; }; /* "imposm/cache/tc.pyx":294 * return osmid * * cdef class RefTagDB(BDB): # <<<<<<<<<<<<<< * """ * Database for items with references and tags (i.e. ways/relations). */ struct __pyx_obj_6imposm_5cache_2tc_RefTagDB { struct __pyx_obj_6imposm_5cache_2tc_BDB __pyx_base; }; /* "imposm/cache/tc.pyx":304 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef class WayDB(RefTagDB): # <<<<<<<<<<<<<< * cdef object _obj(self, int64_t osmid, data): * return Way(osmid, data[0], data[1]) */ struct __pyx_obj_6imposm_5cache_2tc_WayDB { struct __pyx_obj_6imposm_5cache_2tc_RefTagDB __pyx_base; }; /* "imposm/cache/tc.pyx":308 * return Way(osmid, data[0], data[1]) * * cdef class RelationDB(RefTagDB): # <<<<<<<<<<<<<< * cdef object _obj(self, int64_t osmid, data): * return Relation(osmid, data[0], data[1]) */ struct __pyx_obj_6imposm_5cache_2tc_RelationDB { struct __pyx_obj_6imposm_5cache_2tc_RefTagDB __pyx_base; }; /* "imposm/cache/tc.pyx":90 * } * * cdef class BDB: # <<<<<<<<<<<<<< * cdef TCBDB *db * cdef object filename */ struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB { PyObject *(*_obj)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *); PyObject *(*_get_cur)(struct __pyx_obj_6imposm_5cache_2tc_BDB *); }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB *__pyx_vtabptr_6imposm_5cache_2tc_BDB; /* "imposm/cache/tc.pyx":217 * tcbdbdel(self.db) * * cdef class CoordDB(BDB): # <<<<<<<<<<<<<< * def put(self, osmid, x, y): * return self._put(osmid, x, y) */ struct __pyx_vtabstruct_6imposm_5cache_2tc_CoordDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB __pyx_base; int (*_put)(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *, int64_t, double, double); }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_CoordDB *__pyx_vtabptr_6imposm_5cache_2tc_CoordDB; /* "imposm/cache/tc.pyx":260 * return osmid, data * * cdef class NodeDB(BDB): # <<<<<<<<<<<<<< * def put(self, osmid, tags, pos): * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) */ struct __pyx_vtabstruct_6imposm_5cache_2tc_NodeDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB __pyx_base; }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_NodeDB *__pyx_vtabptr_6imposm_5cache_2tc_NodeDB; /* "imposm/cache/tc.pyx":270 * return Node(osmid, data[0], data[1]) * * cdef class InsertedWayDB(BDB): # <<<<<<<<<<<<<< * def put(self, int64_t osmid): * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); */ struct __pyx_vtabstruct_6imposm_5cache_2tc_InsertedWayDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB __pyx_base; }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_InsertedWayDB *__pyx_vtabptr_6imposm_5cache_2tc_InsertedWayDB; /* "imposm/cache/tc.pyx":294 * return osmid * * cdef class RefTagDB(BDB): # <<<<<<<<<<<<<< * """ * Database for items with references and tags (i.e. ways/relations). */ struct __pyx_vtabstruct_6imposm_5cache_2tc_RefTagDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB __pyx_base; }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_RefTagDB *__pyx_vtabptr_6imposm_5cache_2tc_RefTagDB; /* "imposm/cache/tc.pyx":304 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef class WayDB(RefTagDB): # <<<<<<<<<<<<<< * cdef object _obj(self, int64_t osmid, data): * return Way(osmid, data[0], data[1]) */ struct __pyx_vtabstruct_6imposm_5cache_2tc_WayDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_RefTagDB __pyx_base; }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_WayDB *__pyx_vtabptr_6imposm_5cache_2tc_WayDB; /* "imposm/cache/tc.pyx":308 * return Way(osmid, data[0], data[1]) * * cdef class RelationDB(RefTagDB): # <<<<<<<<<<<<<< * cdef object _obj(self, int64_t osmid, data): * return Relation(osmid, data[0], data[1]) */ struct __pyx_vtabstruct_6imposm_5cache_2tc_RelationDB { struct __pyx_vtabstruct_6imposm_5cache_2tc_RefTagDB __pyx_base; }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_RelationDB *__pyx_vtabptr_6imposm_5cache_2tc_RelationDB; #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil) \ if (acquire_gil) { \ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ PyGILState_Release(__pyx_gilstate_save); \ } else { \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil) \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext() \ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_XDECREF(tmp); \ } while (0) #define __Pyx_DECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_DECREF(tmp); \ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ const char* function_name); static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); static CYTHON_INLINE int __Pyx_IterFinish(void); static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif #include static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals #else #define __Pyx_PyString_Equals __Pyx_PyBytes_Equals #endif static CYTHON_INLINE int __Pyx_PySequence_Contains(PyObject* item, PyObject* seq, int eq) { int result = PySequence_Contains(seq, item); return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); } static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); static int __Pyx_SetVtable(PyObject *dict, void *vtable); static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); #define __Pyx_CyFunction_USED 1 #include #define __Pyx_CYFUNCTION_STATICMETHOD 0x01 #define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 #define __Pyx_CYFUNCTION_CCLASS 0x04 #define __Pyx_CyFunction_GetClosure(f) \ (((__pyx_CyFunctionObject *) (f))->func_closure) #define __Pyx_CyFunction_GetClassObj(f) \ (((__pyx_CyFunctionObject *) (f))->func_classobj) #define __Pyx_CyFunction_Defaults(type, f) \ ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) #define __Pyx_CyFunction_SetDefaultsGetter(f, g) \ ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) typedef struct { PyCFunctionObject func; #if PY_VERSION_HEX < 0x030500A0 PyObject *func_weakreflist; #endif PyObject *func_dict; PyObject *func_name; PyObject *func_qualname; PyObject *func_doc; PyObject *func_globals; PyObject *func_code; PyObject *func_closure; PyObject *func_classobj; void *defaults; int defaults_pyobjects; int flags; PyObject *defaults_tuple; PyObject *defaults_kwdict; PyObject *(*defaults_getter)(PyObject *); PyObject *func_annotations; } __pyx_CyFunctionObject; static PyTypeObject *__pyx_CyFunctionType = 0; #define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code) \ __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *self, PyObject *module, PyObject *globals, PyObject* code); static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, size_t size, int pyobjects); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, PyObject *tuple); static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, PyObject *dict); static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, PyObject *dict); static int __Pyx_CyFunction_init(void); static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc); static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); typedef struct { int code_line; PyCodeObject* code_object; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static int __Pyx_check_binary_version(void); static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_f_6imposm_5cache_2tc_3BDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, CYTHON_UNUSED int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_3BDB__get_cur(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto*/ static int __pyx_f_6imposm_5cache_2tc_7CoordDB__put(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_x, double __pyx_v_y); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_7CoordDB__get_cur(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_7CoordDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_6NodeDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_5WayDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_WayDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_10RelationDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_RelationDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto*/ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'imposm.cache.tc' */ static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_BDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_CoordDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_NodeDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_InsertedWayDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_RefTagDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_WayDB = 0; static PyTypeObject *__pyx_ptype_6imposm_5cache_2tc_RelationDB = 0; static uint32_t __pyx_f_6imposm_5cache_2tc__coord_to_uint32(double); /*proto*/ static double __pyx_f_6imposm_5cache_2tc__uint32_to_coord(uint32_t); /*proto*/ static CYTHON_INLINE __pyx_t_6imposm_5cache_2tc_coord __pyx_f_6imposm_5cache_2tc_coord_struct(double, double); /*proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_unzip_nodes(PyObject *); /*proto*/ static PyObject *__pyx_f_6imposm_5cache_2tc_zip_nodes(PyObject *, PyObject *, PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "imposm.cache.tc" int __pyx_module_is_main_imposm__cache__tc = 0; /* Implementation of 'imposm.cache.tc' */ static PyObject *__pyx_builtin_object; static PyObject *__pyx_builtin_IOError; static PyObject *__pyx_builtin_StopIteration; static PyObject *__pyx_builtin_range; static int __pyx_pf_6imposm_5cache_2tc_3BDB___cinit__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_filename, CYTHON_UNUSED PyObject *__pyx_v_mode, CYTHON_UNUSED PyObject *__pyx_v_estimated_records); /* proto */ static int __pyx_pf_6imposm_5cache_2tc_3BDB_2__init__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_mode, PyObject *__pyx_v_estimated_records); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_4_tune_db(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, PyObject *__pyx_v_estimated_records); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_6get(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_8get_raw(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_10put(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_12put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_14__iter__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto */ static int __pyx_pf_6imposm_5cache_2tc_3BDB_16__contains__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static Py_ssize_t __pyx_pf_6imposm_5cache_2tc_3BDB_18__len__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_20__next__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_22close(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto */ static void __pyx_pf_6imposm_5cache_2tc_3BDB_24__dealloc__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_put(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_x, PyObject *__pyx_v_y); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_4get(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_6get_coords(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_refs); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_6NodeDB_put(struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_tags, PyObject *__pyx_v_pos); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_6NodeDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_put(struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_2__next__(struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_8RefTagDB_put(struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_tags, PyObject *__pyx_v_refs); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_8RefTagDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_2changed(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_4get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_6add(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_lon, double __pyx_v_lat); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_8serialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_10deserialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_mode, PyObject *__pyx_v_estimated_records, PyObject *__pyx_v_delta_nodes_cache_size, PyObject *__pyx_v_delta_nodes_size); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_lon, double __pyx_v_lat); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_4get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_osmid); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_6get_coords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_osmids); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_8close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_10_put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id, PyObject *__pyx_v_delta_node); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_12_get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id); /* proto */ static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_14fetch_delta_node(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id); /* proto */ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_BDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_CoordDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_NodeDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_InsertedWayDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_RefTagDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_WayDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6imposm_5cache_2tc_RelationDB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static char __pyx_k_i[] = "i"; static char __pyx_k_r[] = "r"; static char __pyx_k_w[] = "w"; static char __pyx_k_x[] = "x"; static char __pyx_k_y[] = "y"; static char __pyx_k_db[] = "db"; static char __pyx_k_Way[] = "Way"; static char __pyx_k_add[] = "add"; static char __pyx_k_doc[] = "__doc__"; static char __pyx_k_get[] = "get"; static char __pyx_k_ids[] = "ids"; static char __pyx_k_lat[] = "lat"; static char __pyx_k_lon[] = "lon"; static char __pyx_k_pop[] = "pop"; static char __pyx_k_pos[] = "pos"; static char __pyx_k_put[] = "_put"; static char __pyx_k_Node[] = "Node"; static char __pyx_k_data[] = "data"; static char __pyx_k_init[] = "__init__"; static char __pyx_k_lats[] = "lats"; static char __pyx_k_lons[] = "lons"; static char __pyx_k_main[] = "__main__"; static char __pyx_k_mode[] = "mode"; static char __pyx_k_node[] = "node"; static char __pyx_k_refs[] = "refs"; static char __pyx_k_self[] = "self"; static char __pyx_k_tags[] = "tags"; static char __pyx_k_test[] = "__test__"; static char __pyx_k_close[] = "close"; static char __pyx_k_coord[] = "coord"; static char __pyx_k_deque[] = "deque"; static char __pyx_k_get_2[] = "_get"; static char __pyx_k_modes[] = "_modes"; static char __pyx_k_nodes[] = "nodes"; static char __pyx_k_osmid[] = "osmid"; static char __pyx_k_put_2[] = "put"; static char __pyx_k_range[] = "range"; static char __pyx_k_rm_id[] = "rm_id"; static char __pyx_k_append[] = "append"; static char __pyx_k_bisect[] = "bisect"; static char __pyx_k_coords[] = "coords"; static char __pyx_k_import[] = "__import__"; static char __pyx_k_insort[] = "insort"; static char __pyx_k_module[] = "__module__"; static char __pyx_k_object[] = "object"; static char __pyx_k_osmids[] = "osmids"; static char __pyx_k_IOError[] = "IOError"; static char __pyx_k_changed[] = "changed"; static char __pyx_k_get_raw[] = "get_raw"; static char __pyx_k_node_id[] = "node_id"; static char __pyx_k_popleft[] = "popleft"; static char __pyx_k_prepare[] = "__prepare__"; static char __pyx_k_rm_node[] = "rm_node"; static char __pyx_k_tune_db[] = "_tune_db"; static char __pyx_k_Relation[] = "Relation"; static char __pyx_k_delta_id[] = "delta_id"; static char __pyx_k_filename[] = "filename"; static char __pyx_k_new_node[] = "new_node"; static char __pyx_k_qualname[] = "__qualname__"; static char __pyx_k_iteritems[] = "iteritems"; static char __pyx_k_metaclass[] = "__metaclass__"; static char __pyx_k_serialize[] = "serialize"; static char __pyx_k_DeltaNodes[] = "DeltaNodes"; static char __pyx_k_delta_node[] = "delta_node"; static char __pyx_k_get_coords[] = "get_coords"; static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static char __pyx_k_DeltaCoords[] = "_DeltaCoords"; static char __pyx_k_collections[] = "collections"; static char __pyx_k_delta_nodes[] = "delta_nodes"; static char __pyx_k_deserialize[] = "deserialize"; static char __pyx_k_imposm_base[] = "imposm.base"; static char __pyx_k_DeltaCoordsDB[] = "DeltaCoordsDB"; static char __pyx_k_DeltaCoords_2[] = "DeltaCoords"; static char __pyx_k_StopIteration[] = "StopIteration"; static char __pyx_k_put_marshaled[] = "put_marshaled"; static char __pyx_k_DeltaNodes_add[] = "DeltaNodes.add"; static char __pyx_k_DeltaNodes_get[] = "DeltaNodes.get"; static char __pyx_k_delta_node_ids[] = "delta_node_ids"; static char __pyx_k_ParseFromString[] = "ParseFromString"; static char __pyx_k_imposm_cache_tc[] = "imposm.cache.tc"; static char __pyx_k_delta_nodes_size[] = "delta_nodes_size"; static char __pyx_k_fetch_delta_node[] = "fetch_delta_node"; static char __pyx_k_DeltaCoordsDB_get[] = "DeltaCoordsDB.get"; static char __pyx_k_DeltaCoordsDB_put[] = "DeltaCoordsDB.put"; static char __pyx_k_DeltaNodes___init[] = "DeltaNodes.__init__"; static char __pyx_k_SerializeToString[] = "SerializeToString"; static char __pyx_k_estimated_records[] = "estimated_records"; static char __pyx_k_DeltaCoordsDB__get[] = "DeltaCoordsDB._get"; static char __pyx_k_DeltaCoordsDB__put[] = "DeltaCoordsDB._put"; static char __pyx_k_DeltaNodes_changed[] = "DeltaNodes.changed"; static char __pyx_k_DeltaCoordsDB_close[] = "DeltaCoordsDB.close"; static char __pyx_k_DeltaCoordsDB___init[] = "DeltaCoordsDB.__init__"; static char __pyx_k_DeltaNodes_serialize[] = "DeltaNodes.serialize"; static char __pyx_k_imposm_cache_internal[] = "imposm.cache.internal"; static char __pyx_k_DeltaNodes_deserialize[] = "DeltaNodes.deserialize"; static char __pyx_k_delta_nodes_cache_size[] = "delta_nodes_cache_size"; static char __pyx_k_DeltaCoordsDB_get_coords[] = "DeltaCoordsDB.get_coords"; static char __pyx_k_DeltaCoordsDB_fetch_delta_node[] = "DeltaCoordsDB.fetch_delta_node"; static char __pyx_k_Users_olt_dev_imposm_git_imposm[] = "/Users/olt/dev/imposm.git/imposm/cache/tc.pyx"; static PyObject *__pyx_n_s_DeltaCoords; static PyObject *__pyx_n_s_DeltaCoordsDB; static PyObject *__pyx_n_s_DeltaCoordsDB___init; static PyObject *__pyx_n_s_DeltaCoordsDB__get; static PyObject *__pyx_n_s_DeltaCoordsDB__put; static PyObject *__pyx_n_s_DeltaCoordsDB_close; static PyObject *__pyx_n_s_DeltaCoordsDB_fetch_delta_node; static PyObject *__pyx_n_s_DeltaCoordsDB_get; static PyObject *__pyx_n_s_DeltaCoordsDB_get_coords; static PyObject *__pyx_n_s_DeltaCoordsDB_put; static PyObject *__pyx_n_s_DeltaCoords_2; static PyObject *__pyx_n_s_DeltaNodes; static PyObject *__pyx_n_s_DeltaNodes___init; static PyObject *__pyx_n_s_DeltaNodes_add; static PyObject *__pyx_n_s_DeltaNodes_changed; static PyObject *__pyx_n_s_DeltaNodes_deserialize; static PyObject *__pyx_n_s_DeltaNodes_get; static PyObject *__pyx_n_s_DeltaNodes_serialize; static PyObject *__pyx_n_s_IOError; static PyObject *__pyx_n_s_Node; static PyObject *__pyx_n_s_ParseFromString; static PyObject *__pyx_n_s_Relation; static PyObject *__pyx_n_s_SerializeToString; static PyObject *__pyx_n_s_StopIteration; static PyObject *__pyx_kp_s_Users_olt_dev_imposm_git_imposm; static PyObject *__pyx_n_s_Way; static PyObject *__pyx_n_s_add; static PyObject *__pyx_n_s_append; static PyObject *__pyx_n_s_bisect; static PyObject *__pyx_n_s_changed; static PyObject *__pyx_n_s_close; static PyObject *__pyx_n_s_collections; static PyObject *__pyx_n_s_coord; static PyObject *__pyx_n_s_coords; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_db; static PyObject *__pyx_n_s_delta_id; static PyObject *__pyx_n_s_delta_node; static PyObject *__pyx_n_s_delta_node_ids; static PyObject *__pyx_n_s_delta_nodes; static PyObject *__pyx_n_s_delta_nodes_cache_size; static PyObject *__pyx_n_s_delta_nodes_size; static PyObject *__pyx_n_s_deque; static PyObject *__pyx_n_s_deserialize; static PyObject *__pyx_n_s_doc; static PyObject *__pyx_n_s_estimated_records; static PyObject *__pyx_n_s_fetch_delta_node; static PyObject *__pyx_n_s_filename; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_get_2; static PyObject *__pyx_n_s_get_coords; static PyObject *__pyx_n_s_get_raw; static PyObject *__pyx_n_s_i; static PyObject *__pyx_n_s_ids; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_imposm_base; static PyObject *__pyx_n_s_imposm_cache_internal; static PyObject *__pyx_n_s_imposm_cache_tc; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_insort; static PyObject *__pyx_n_s_iteritems; static PyObject *__pyx_n_s_lat; static PyObject *__pyx_n_s_lats; static PyObject *__pyx_n_s_lon; static PyObject *__pyx_n_s_lons; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_metaclass; static PyObject *__pyx_n_s_mode; static PyObject *__pyx_n_s_modes; static PyObject *__pyx_n_s_module; static PyObject *__pyx_n_s_new_node; static PyObject *__pyx_n_s_node; static PyObject *__pyx_n_s_node_id; static PyObject *__pyx_n_s_nodes; static PyObject *__pyx_n_s_object; static PyObject *__pyx_n_s_osmid; static PyObject *__pyx_n_s_osmids; static PyObject *__pyx_n_s_pop; static PyObject *__pyx_n_s_popleft; static PyObject *__pyx_n_s_pos; static PyObject *__pyx_n_s_prepare; static PyObject *__pyx_n_s_put; static PyObject *__pyx_n_s_put_2; static PyObject *__pyx_n_s_put_marshaled; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_qualname; static PyObject *__pyx_n_s_r; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_refs; static PyObject *__pyx_n_s_rm_id; static PyObject *__pyx_n_s_rm_node; static PyObject *__pyx_n_s_self; static PyObject *__pyx_n_s_serialize; static PyObject *__pyx_n_s_tags; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_tune_db; static PyObject *__pyx_n_s_w; static PyObject *__pyx_n_s_x; static PyObject *__pyx_n_s_y; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_3; static PyObject *__pyx_int_6; static PyObject *__pyx_int_100; static PyObject *__pyx_int_128; static PyObject *__pyx_slice_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__28; static PyObject *__pyx_tuple__30; static PyObject *__pyx_codeobj__3; static PyObject *__pyx_codeobj__6; static PyObject *__pyx_codeobj__8; static PyObject *__pyx_codeobj__10; static PyObject *__pyx_codeobj__12; static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__16; static PyObject *__pyx_codeobj__19; static PyObject *__pyx_codeobj__21; static PyObject *__pyx_codeobj__23; static PyObject *__pyx_codeobj__25; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__31; /* "imposm/cache/tc.pyx":69 * DEF COORD_FACTOR = 11930464.7083 # ((2<<31)-1)/360.0 * * cdef uint32_t _coord_to_uint32(double x) nogil: # <<<<<<<<<<<<<< * return ((x + 180.0) * COORD_FACTOR) * */ static uint32_t __pyx_f_6imposm_5cache_2tc__coord_to_uint32(double __pyx_v_x) { uint32_t __pyx_r; /* "imposm/cache/tc.pyx":70 * * cdef uint32_t _coord_to_uint32(double x) nogil: * return ((x + 180.0) * COORD_FACTOR) # <<<<<<<<<<<<<< * * cdef double _uint32_to_coord(uint32_t x) nogil: */ __pyx_r = ((uint32_t)((__pyx_v_x + 180.0) * 11930464.7083)); goto __pyx_L0; /* "imposm/cache/tc.pyx":69 * DEF COORD_FACTOR = 11930464.7083 # ((2<<31)-1)/360.0 * * cdef uint32_t _coord_to_uint32(double x) nogil: # <<<<<<<<<<<<<< * return ((x + 180.0) * COORD_FACTOR) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "imposm/cache/tc.pyx":72 * return ((x + 180.0) * COORD_FACTOR) * * cdef double _uint32_to_coord(uint32_t x) nogil: # <<<<<<<<<<<<<< * return ((x / COORD_FACTOR) - 180.0) * */ static double __pyx_f_6imposm_5cache_2tc__uint32_to_coord(uint32_t __pyx_v_x) { double __pyx_r; /* "imposm/cache/tc.pyx":73 * * cdef double _uint32_to_coord(uint32_t x) nogil: * return ((x / COORD_FACTOR) - 180.0) # <<<<<<<<<<<<<< * * ctypedef struct coord: */ __pyx_r = ((double)((__pyx_v_x / 11930464.7083) - 180.0)); goto __pyx_L0; /* "imposm/cache/tc.pyx":72 * return ((x + 180.0) * COORD_FACTOR) * * cdef double _uint32_to_coord(uint32_t x) nogil: # <<<<<<<<<<<<<< * return ((x / COORD_FACTOR) - 180.0) * */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "imposm/cache/tc.pyx":79 * uint32_t y * * cdef inline coord coord_struct(double x, double y) nogil: # <<<<<<<<<<<<<< * cdef coord p * p.x = _coord_to_uint32(x) */ static CYTHON_INLINE __pyx_t_6imposm_5cache_2tc_coord __pyx_f_6imposm_5cache_2tc_coord_struct(double __pyx_v_x, double __pyx_v_y) { __pyx_t_6imposm_5cache_2tc_coord __pyx_v_p; __pyx_t_6imposm_5cache_2tc_coord __pyx_r; /* "imposm/cache/tc.pyx":81 * cdef inline coord coord_struct(double x, double y) nogil: * cdef coord p * p.x = _coord_to_uint32(x) # <<<<<<<<<<<<<< * p.y = _coord_to_uint32(y) * return p */ __pyx_v_p.x = __pyx_f_6imposm_5cache_2tc__coord_to_uint32(__pyx_v_x); /* "imposm/cache/tc.pyx":82 * cdef coord p * p.x = _coord_to_uint32(x) * p.y = _coord_to_uint32(y) # <<<<<<<<<<<<<< * return p * */ __pyx_v_p.y = __pyx_f_6imposm_5cache_2tc__coord_to_uint32(__pyx_v_y); /* "imposm/cache/tc.pyx":83 * p.x = _coord_to_uint32(x) * p.y = _coord_to_uint32(y) * return p # <<<<<<<<<<<<<< * * _modes = { */ __pyx_r = __pyx_v_p; goto __pyx_L0; /* "imposm/cache/tc.pyx":79 * uint32_t y * * cdef inline coord coord_struct(double x, double y) nogil: # <<<<<<<<<<<<<< * cdef coord p * p.x = _coord_to_uint32(x) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "imposm/cache/tc.pyx":95 * cdef int _opened * cdef BDBCUR *_cur * def __cinit__(self, filename, mode='w', estimated_records=0): # <<<<<<<<<<<<<< * self.db = tcbdbnew() * self._opened = 0 */ /* Python wrapper */ static int __pyx_pw_6imposm_5cache_2tc_3BDB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6imposm_5cache_2tc_3BDB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_filename = 0; CYTHON_UNUSED PyObject *__pyx_v_mode = 0; CYTHON_UNUSED PyObject *__pyx_v_estimated_records = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_mode,&__pyx_n_s_estimated_records,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_n_s_w); values[2] = ((PyObject *)__pyx_int_0); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mode); if (value) { values[1] = value; kw_args--; } } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_estimated_records); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_filename = values[0]; __pyx_v_mode = values[1]; __pyx_v_estimated_records = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB___cinit__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), __pyx_v_filename, __pyx_v_mode, __pyx_v_estimated_records); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6imposm_5cache_2tc_3BDB___cinit__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_filename, CYTHON_UNUSED PyObject *__pyx_v_mode, CYTHON_UNUSED PyObject *__pyx_v_estimated_records) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__", 0); /* "imposm/cache/tc.pyx":96 * cdef BDBCUR *_cur * def __cinit__(self, filename, mode='w', estimated_records=0): * self.db = tcbdbnew() # <<<<<<<<<<<<<< * self._opened = 0 * */ __pyx_v_self->db = tcbdbnew(); /* "imposm/cache/tc.pyx":97 * def __cinit__(self, filename, mode='w', estimated_records=0): * self.db = tcbdbnew() * self._opened = 0 # <<<<<<<<<<<<<< * * def __init__(self, filename, mode='w', estimated_records=0): */ __pyx_v_self->_opened = 0; /* "imposm/cache/tc.pyx":95 * cdef int _opened * cdef BDBCUR *_cur * def __cinit__(self, filename, mode='w', estimated_records=0): # <<<<<<<<<<<<<< * self.db = tcbdbnew() * self._opened = 0 */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":99 * self._opened = 0 * * def __init__(self, filename, mode='w', estimated_records=0): # <<<<<<<<<<<<<< * self.filename = filename * self._tune_db(estimated_records) */ /* Python wrapper */ static int __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_filename = 0; PyObject *__pyx_v_mode = 0; PyObject *__pyx_v_estimated_records = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filename,&__pyx_n_s_mode,&__pyx_n_s_estimated_records,0}; PyObject* values[3] = {0,0,0}; values[1] = ((PyObject *)__pyx_n_s_w); values[2] = ((PyObject *)__pyx_int_0); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mode); if (value) { values[1] = value; kw_args--; } } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_estimated_records); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_filename = values[0]; __pyx_v_mode = values[1]; __pyx_v_estimated_records = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_2__init__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), __pyx_v_filename, __pyx_v_mode, __pyx_v_estimated_records); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6imposm_5cache_2tc_3BDB_2__init__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_mode, PyObject *__pyx_v_estimated_records) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "imposm/cache/tc.pyx":100 * * def __init__(self, filename, mode='w', estimated_records=0): * self.filename = filename # <<<<<<<<<<<<<< * self._tune_db(estimated_records) * tcbdbsetcmpfunc(self.db, tccmpint64, NULL) */ __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); __Pyx_GOTREF(__pyx_v_self->filename); __Pyx_DECREF(__pyx_v_self->filename); __pyx_v_self->filename = __pyx_v_filename; /* "imposm/cache/tc.pyx":101 * def __init__(self, filename, mode='w', estimated_records=0): * self.filename = filename * self._tune_db(estimated_records) # <<<<<<<<<<<<<< * tcbdbsetcmpfunc(self.db, tccmpint64, NULL) * if not tcbdbopen(self.db, filename, _modes[mode]): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_tune_db); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_estimated_records); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; __Pyx_INCREF(__pyx_v_estimated_records); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_estimated_records); __Pyx_GIVEREF(__pyx_v_estimated_records); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":102 * self.filename = filename * self._tune_db(estimated_records) * tcbdbsetcmpfunc(self.db, tccmpint64, NULL) # <<<<<<<<<<<<<< * if not tcbdbopen(self.db, filename, _modes[mode]): * raise IOError(tcbdbecode(self.db)) */ tcbdbsetcmpfunc(__pyx_v_self->db, tccmpint64, NULL); /* "imposm/cache/tc.pyx":103 * self._tune_db(estimated_records) * tcbdbsetcmpfunc(self.db, tccmpint64, NULL) * if not tcbdbopen(self.db, filename, _modes[mode]): # <<<<<<<<<<<<<< * raise IOError(tcbdbecode(self.db)) * self._opened = 1 */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_filename); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 103; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_modes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 103; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_GetItem(__pyx_t_1, __pyx_v_mode); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 103; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 103; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_7 = ((!(tcbdbopen(__pyx_v_self->db, __pyx_t_5, __pyx_t_6) != 0)) != 0); if (__pyx_t_7) { /* "imposm/cache/tc.pyx":104 * tcbdbsetcmpfunc(self.db, tccmpint64, NULL) * if not tcbdbopen(self.db, filename, _modes[mode]): * raise IOError(tcbdbecode(self.db)) # <<<<<<<<<<<<<< * self._opened = 1 * */ __pyx_t_2 = __Pyx_PyInt_From_int(tcbdbecode(__pyx_v_self->db)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "imposm/cache/tc.pyx":105 * if not tcbdbopen(self.db, filename, _modes[mode]): * raise IOError(tcbdbecode(self.db)) * self._opened = 1 # <<<<<<<<<<<<<< * * def _tune_db(self, estimated_records): */ __pyx_v_self->_opened = 1; /* "imposm/cache/tc.pyx":99 * self._opened = 0 * * def __init__(self, filename, mode='w', estimated_records=0): # <<<<<<<<<<<<<< * self.filename = filename * self._tune_db(estimated_records) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.BDB.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":107 * self._opened = 1 * * def _tune_db(self, estimated_records): # <<<<<<<<<<<<<< * if estimated_records: * lmemb = 128 # default */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_5_tune_db(PyObject *__pyx_v_self, PyObject *__pyx_v_estimated_records); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_5_tune_db(PyObject *__pyx_v_self, PyObject *__pyx_v_estimated_records) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_tune_db (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_4_tune_db(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), ((PyObject *)__pyx_v_estimated_records)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_4_tune_db(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, PyObject *__pyx_v_estimated_records) { PyObject *__pyx_v_lmemb = NULL; long __pyx_v_nmemb; long __pyx_v_fpow; PyObject *__pyx_v_bnum = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_tune_db", 0); /* "imposm/cache/tc.pyx":108 * * def _tune_db(self, estimated_records): * if estimated_records: # <<<<<<<<<<<<<< * lmemb = 128 # default * nmemb = -1 */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_estimated_records); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "imposm/cache/tc.pyx":109 * def _tune_db(self, estimated_records): * if estimated_records: * lmemb = 128 # default # <<<<<<<<<<<<<< * nmemb = -1 * fpow = 13 # 2^13 = 8196 */ __Pyx_INCREF(__pyx_int_128); __pyx_v_lmemb = __pyx_int_128; /* "imposm/cache/tc.pyx":110 * if estimated_records: * lmemb = 128 # default * nmemb = -1 # <<<<<<<<<<<<<< * fpow = 13 # 2^13 = 8196 * bnum = int((estimated_records*3)/lmemb) */ __pyx_v_nmemb = -1; /* "imposm/cache/tc.pyx":111 * lmemb = 128 # default * nmemb = -1 * fpow = 13 # 2^13 = 8196 # <<<<<<<<<<<<<< * bnum = int((estimated_records*3)/lmemb) * tcbdbtune(self.db, lmemb, nmemb, bnum, 5, fpow, BDBTLARGE | BDBTDEFLATE) */ __pyx_v_fpow = 13; /* "imposm/cache/tc.pyx":112 * nmemb = -1 * fpow = 13 # 2^13 = 8196 * bnum = int((estimated_records*3)/lmemb) # <<<<<<<<<<<<<< * tcbdbtune(self.db, lmemb, nmemb, bnum, 5, fpow, BDBTLARGE | BDBTDEFLATE) * else: */ __pyx_t_2 = PyNumber_Multiply(__pyx_v_estimated_records, __pyx_int_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_v_lmemb); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyNumber_Int(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_bnum = __pyx_t_2; __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":113 * fpow = 13 # 2^13 = 8196 * bnum = int((estimated_records*3)/lmemb) * tcbdbtune(self.db, lmemb, nmemb, bnum, 5, fpow, BDBTLARGE | BDBTDEFLATE) # <<<<<<<<<<<<<< * else: * tcbdbtune(self.db, -1, -1, -1, 5, 13, BDBTLARGE | BDBTDEFLATE) */ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_lmemb); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_bnum); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} tcbdbtune(__pyx_v_self->db, __pyx_t_4, __pyx_v_nmemb, __pyx_t_5, 5, __pyx_v_fpow, (BDBTLARGE | BDBTDEFLATE)); goto __pyx_L3; } /*else*/ { /* "imposm/cache/tc.pyx":115 * tcbdbtune(self.db, lmemb, nmemb, bnum, 5, fpow, BDBTLARGE | BDBTDEFLATE) * else: * tcbdbtune(self.db, -1, -1, -1, 5, 13, BDBTLARGE | BDBTDEFLATE) # <<<<<<<<<<<<<< * * def get(self, int64_t osmid): */ tcbdbtune(__pyx_v_self->db, -1, -1, -1, 5, 13, (BDBTLARGE | BDBTDEFLATE)); } __pyx_L3:; /* "imposm/cache/tc.pyx":107 * self._opened = 1 * * def _tune_db(self, estimated_records): # <<<<<<<<<<<<<< * if estimated_records: * lmemb = 128 # default */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.BDB._tune_db", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_lmemb); __Pyx_XDECREF(__pyx_v_bnum); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":117 * tcbdbtune(self.db, -1, -1, -1, 5, 13, BDBTLARGE | BDBTDEFLATE) * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * """ * Return object with given id. */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_7get(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid); /*proto*/ static char __pyx_doc_6imposm_5cache_2tc_3BDB_6get[] = "\n Return object with given id.\n Returns None if id is not stored.\n "; static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_7get(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid) { int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); assert(__pyx_arg_osmid); { __pyx_v_osmid = __Pyx_PyInt_As_int64_t(__pyx_arg_osmid); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 117; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_6get(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), ((int64_t)__pyx_v_osmid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_6get(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid) { void *__pyx_v_ret; int __pyx_v_ret_size; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); /* "imposm/cache/tc.pyx":124 * cdef void *ret * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) # <<<<<<<<<<<<<< * if not ret: return None * return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) */ __pyx_v_ret = tcbdbget3(__pyx_v_self->db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), (&__pyx_v_ret_size)); /* "imposm/cache/tc.pyx":125 * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not ret: return None # <<<<<<<<<<<<<< * return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) * */ __pyx_t_1 = ((!(__pyx_v_ret != 0)) != 0); if (__pyx_t_1) { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; } /* "imposm/cache/tc.pyx":126 * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not ret: return None * return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) # <<<<<<<<<<<<<< * * def get_raw(self, int64_t osmid): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyMarshal_ReadObjectFromString(((char *)__pyx_v_ret), __pyx_v_ret_size); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 126; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = ((struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB *)__pyx_v_self->__pyx_vtab)->_obj(__pyx_v_self, __pyx_v_osmid, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 126; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":117 * tcbdbtune(self.db, -1, -1, -1, 5, 13, BDBTLARGE | BDBTDEFLATE) * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * """ * Return object with given id. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.BDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":128 * return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) * * def get_raw(self, int64_t osmid): # <<<<<<<<<<<<<< * """ * Return object with given id. */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_9get_raw(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid); /*proto*/ static char __pyx_doc_6imposm_5cache_2tc_3BDB_8get_raw[] = "\n Return object with given id.\n Returns None if id is not stored.\n "; static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_9get_raw(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid) { int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_raw (wrapper)", 0); assert(__pyx_arg_osmid); { __pyx_v_osmid = __Pyx_PyInt_As_int64_t(__pyx_arg_osmid); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 128; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.get_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_8get_raw(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), ((int64_t)__pyx_v_osmid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_8get_raw(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid) { void *__pyx_v_ret; int __pyx_v_ret_size; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_raw", 0); /* "imposm/cache/tc.pyx":135 * cdef void *ret * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) # <<<<<<<<<<<<<< * if not ret: return None * return PyString_FromStringAndSize(ret, ret_size) */ __pyx_v_ret = tcbdbget3(__pyx_v_self->db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), (&__pyx_v_ret_size)); /* "imposm/cache/tc.pyx":136 * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not ret: return None # <<<<<<<<<<<<<< * return PyString_FromStringAndSize(ret, ret_size) * */ __pyx_t_1 = ((!(__pyx_v_ret != 0)) != 0); if (__pyx_t_1) { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; } /* "imposm/cache/tc.pyx":137 * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not ret: return None * return PyString_FromStringAndSize(ret, ret_size) # <<<<<<<<<<<<<< * * def put(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyString_FromStringAndSize(((char *)__pyx_v_ret), __pyx_v_ret_size); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 137; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":128 * return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) * * def get_raw(self, int64_t osmid): # <<<<<<<<<<<<<< * """ * Return object with given id. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("imposm.cache.tc.BDB.get_raw", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":139 * return PyString_FromStringAndSize(ret, ret_size) * * def put(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_11put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_11put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64_t __pyx_v_osmid; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_10put(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_10put(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":140 * * def put(self, int64_t osmid, data): * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) # <<<<<<<<<<<<<< * * def put_marshaled(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_put_marshaled); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 140; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 140; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyMarshal_WriteObjectToString(__pyx_v_data, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 140; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 140; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 140; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":139 * return PyString_FromStringAndSize(ret, ret_size) * * def put(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("imposm.cache.tc.BDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":142 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_13put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_13put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64_t __pyx_v_osmid; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put_marshaled (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put_marshaled") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_12put_marshaled(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_12put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations char *__pyx_t_1; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put_marshaled", 0); /* "imposm/cache/tc.pyx":143 * * def put_marshaled(self, int64_t osmid, data): * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) # <<<<<<<<<<<<<< * * cdef object _obj(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_data); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyBool_FromLong(tcbdbput(__pyx_v_self->db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), ((char *)__pyx_t_1), __pyx_t_2)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":142 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.BDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":145 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * """ * Create an object from the id and unmarshaled data. */ static PyObject *__pyx_f_6imposm_5cache_2tc_3BDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, CYTHON_UNUSED int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_obj", 0); /* "imposm/cache/tc.pyx":150 * Should be overridden by subclasses. * """ * return data # <<<<<<<<<<<<<< * * def __iter__(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_data); __pyx_r = __pyx_v_data; goto __pyx_L0; /* "imposm/cache/tc.pyx":145 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * """ * Create an object from the id and unmarshaled data. */ /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":152 * return data * * def __iter__(self): # <<<<<<<<<<<<<< * """ * Return an iterator over the database. */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__(PyObject *__pyx_v_self); /*proto*/ static char __pyx_doc_6imposm_5cache_2tc_3BDB_14__iter__[] = "\n Return an iterator over the database.\n Resets any existing iterator.\n "; #if CYTHON_COMPILING_IN_CPYTHON struct wrapperbase __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_14__iter__; #endif static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_14__iter__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_14__iter__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__iter__", 0); /* "imposm/cache/tc.pyx":157 * Resets any existing iterator. * """ * if self._cur: # <<<<<<<<<<<<<< * tcbdbcurdel(self._cur) * self._cur = tcbdbcurnew(self.db) */ __pyx_t_1 = (__pyx_v_self->_cur != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":158 * """ * if self._cur: * tcbdbcurdel(self._cur) # <<<<<<<<<<<<<< * self._cur = tcbdbcurnew(self.db) * if not tcbdbcurfirst(self._cur): */ tcbdbcurdel(__pyx_v_self->_cur); goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":159 * if self._cur: * tcbdbcurdel(self._cur) * self._cur = tcbdbcurnew(self.db) # <<<<<<<<<<<<<< * if not tcbdbcurfirst(self._cur): * return iter([]) */ __pyx_v_self->_cur = tcbdbcurnew(__pyx_v_self->db); /* "imposm/cache/tc.pyx":160 * tcbdbcurdel(self._cur) * self._cur = tcbdbcurnew(self.db) * if not tcbdbcurfirst(self._cur): # <<<<<<<<<<<<<< * return iter([]) * return self */ __pyx_t_1 = ((!(tcbdbcurfirst(__pyx_v_self->_cur) != 0)) != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":161 * self._cur = tcbdbcurnew(self.db) * if not tcbdbcurfirst(self._cur): * return iter([]) # <<<<<<<<<<<<<< * return self * */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "imposm/cache/tc.pyx":162 * if not tcbdbcurfirst(self._cur): * return iter([]) * return self # <<<<<<<<<<<<<< * * def __contains__(self, int64_t osmid): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_self)); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; /* "imposm/cache/tc.pyx":152 * return data * * def __iter__(self): # <<<<<<<<<<<<<< * """ * Return an iterator over the database. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.BDB.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":164 * return self * * def __contains__(self, int64_t osmid): # <<<<<<<<<<<<<< * cdef void *ret * cdef int ret_size */ /* Python wrapper */ static int __pyx_pw_6imposm_5cache_2tc_3BDB_17__contains__(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid); /*proto*/ static int __pyx_pw_6imposm_5cache_2tc_3BDB_17__contains__(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid) { int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0); assert(__pyx_arg_osmid); { __pyx_v_osmid = __Pyx_PyInt_As_int64_t(__pyx_arg_osmid); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 164; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.BDB.__contains__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_16__contains__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self), ((int64_t)__pyx_v_osmid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6imposm_5cache_2tc_3BDB_16__contains__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self, int64_t __pyx_v_osmid) { void *__pyx_v_ret; int __pyx_v_ret_size; int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__contains__", 0); /* "imposm/cache/tc.pyx":167 * cdef void *ret * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size); # <<<<<<<<<<<<<< * if ret: * return 1 */ __pyx_v_ret = tcbdbget3(__pyx_v_self->db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), (&__pyx_v_ret_size)); /* "imposm/cache/tc.pyx":168 * cdef int ret_size * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size); * if ret: # <<<<<<<<<<<<<< * return 1 * else: */ __pyx_t_1 = (__pyx_v_ret != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":169 * ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size); * if ret: * return 1 # <<<<<<<<<<<<<< * else: * return 0 */ __pyx_r = 1; goto __pyx_L0; } /*else*/ { /* "imposm/cache/tc.pyx":171 * return 1 * else: * return 0 # <<<<<<<<<<<<<< * * def __len__(self): */ __pyx_r = 0; goto __pyx_L0; } /* "imposm/cache/tc.pyx":164 * return self * * def __contains__(self, int64_t osmid): # <<<<<<<<<<<<<< * cdef void *ret * cdef int ret_size */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":173 * return 0 * * def __len__(self): # <<<<<<<<<<<<<< * return tcbdbrnum(self.db) * */ /* Python wrapper */ static Py_ssize_t __pyx_pw_6imposm_5cache_2tc_3BDB_19__len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_pw_6imposm_5cache_2tc_3BDB_19__len__(PyObject *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_18__len__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static Py_ssize_t __pyx_pf_6imposm_5cache_2tc_3BDB_18__len__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__", 0); /* "imposm/cache/tc.pyx":174 * * def __len__(self): * return tcbdbrnum(self.db) # <<<<<<<<<<<<<< * * def __next__(self): */ __pyx_r = tcbdbrnum(__pyx_v_self->db); goto __pyx_L0; /* "imposm/cache/tc.pyx":173 * return 0 * * def __len__(self): # <<<<<<<<<<<<<< * return tcbdbrnum(self.db) * */ /* function exit code */ __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":176 * return tcbdbrnum(self.db) * * def __next__(self): # <<<<<<<<<<<<<< * """ * Return next item as object. */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_21__next__(PyObject *__pyx_v_self); /*proto*/ static char __pyx_doc_6imposm_5cache_2tc_3BDB_20__next__[] = "\n Return next item as object.\n "; #if CYTHON_COMPILING_IN_CPYTHON struct wrapperbase __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_20__next__; #endif static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_21__next__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_20__next__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_20__next__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { int64_t __pyx_v_osmid; PyObject *__pyx_v_data = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *(*__pyx_t_6)(PyObject *); int64_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "imposm/cache/tc.pyx":182 * cdef int64_t osmid * * if not self._cur: raise StopIteration # <<<<<<<<<<<<<< * * osmid, data = self._get_cur() */ __pyx_t_1 = ((!(__pyx_v_self->_cur != 0)) != 0); if (__pyx_t_1) { __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 182; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "imposm/cache/tc.pyx":184 * if not self._cur: raise StopIteration * * osmid, data = self._get_cur() # <<<<<<<<<<<<<< * * # advance cursor, set to NULL if at the end */ __pyx_t_2 = ((struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB *)__pyx_v_self->__pyx_vtab)->_get_cur(__pyx_v_self); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_3 = PyList_GET_ITEM(sequence, 0); __pyx_t_4 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; index = 0; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L4_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 1; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L4_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L5_unpacking_done; __pyx_L4_unpacking_failed:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_L5_unpacking_done:; } __pyx_t_7 = __Pyx_PyInt_As_int64_t(__pyx_t_3); if (unlikely((__pyx_t_7 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 184; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_osmid = __pyx_t_7; __pyx_v_data = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":187 * * # advance cursor, set to NULL if at the end * if tcbdbcurnext(self._cur) == 0: # <<<<<<<<<<<<<< * tcbdbcurdel(self._cur) * self._cur = NULL */ __pyx_t_1 = ((tcbdbcurnext(__pyx_v_self->_cur) == 0) != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":188 * # advance cursor, set to NULL if at the end * if tcbdbcurnext(self._cur) == 0: * tcbdbcurdel(self._cur) # <<<<<<<<<<<<<< * self._cur = NULL * */ tcbdbcurdel(__pyx_v_self->_cur); /* "imposm/cache/tc.pyx":189 * if tcbdbcurnext(self._cur) == 0: * tcbdbcurdel(self._cur) * self._cur = NULL # <<<<<<<<<<<<<< * * # return objectified item */ __pyx_v_self->_cur = NULL; goto __pyx_L6; } __pyx_L6:; /* "imposm/cache/tc.pyx":192 * * # return objectified item * return self._obj(osmid, data) # <<<<<<<<<<<<<< * * cdef object _get_cur(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = ((struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB *)__pyx_v_self->__pyx_vtab)->_obj(__pyx_v_self, __pyx_v_osmid, __pyx_v_data); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":176 * return tcbdbrnum(self.db) * * def __next__(self): # <<<<<<<<<<<<<< * """ * Return next item as object. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("imposm.cache.tc.BDB.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_data); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":194 * return self._obj(osmid, data) * * cdef object _get_cur(self): # <<<<<<<<<<<<<< * """ * Return the current object at the current cursor position */ static PyObject *__pyx_f_6imposm_5cache_2tc_3BDB__get_cur(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { int __pyx_v_size; void *__pyx_v_ret; int64_t __pyx_v_osmid; PyObject *__pyx_v_value = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_cur", 0); /* "imposm/cache/tc.pyx":201 * cdef int size * cdef void *ret * ret = tcbdbcurkey3(self._cur, &size) # <<<<<<<<<<<<<< * osmid = (ret)[0] * ret = tcbdbcurval3(self._cur, &size) */ __pyx_v_ret = tcbdbcurkey3(__pyx_v_self->_cur, (&__pyx_v_size)); /* "imposm/cache/tc.pyx":202 * cdef void *ret * ret = tcbdbcurkey3(self._cur, &size) * osmid = (ret)[0] # <<<<<<<<<<<<<< * ret = tcbdbcurval3(self._cur, &size) * value = PyMarshal_ReadObjectFromString(ret, size) */ __pyx_v_osmid = (((int64_t *)__pyx_v_ret)[0]); /* "imposm/cache/tc.pyx":203 * ret = tcbdbcurkey3(self._cur, &size) * osmid = (ret)[0] * ret = tcbdbcurval3(self._cur, &size) # <<<<<<<<<<<<<< * value = PyMarshal_ReadObjectFromString(ret, size) * return osmid, value */ __pyx_v_ret = tcbdbcurval3(__pyx_v_self->_cur, (&__pyx_v_size)); /* "imposm/cache/tc.pyx":204 * osmid = (ret)[0] * ret = tcbdbcurval3(self._cur, &size) * value = PyMarshal_ReadObjectFromString(ret, size) # <<<<<<<<<<<<<< * return osmid, value * */ __pyx_t_1 = PyMarshal_ReadObjectFromString(((char *)__pyx_v_ret), __pyx_v_size); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 204; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = __pyx_t_1; __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":205 * ret = tcbdbcurval3(self._cur, &size) * value = PyMarshal_ReadObjectFromString(ret, size) * return osmid, value # <<<<<<<<<<<<<< * * def close(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 205; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 205; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":194 * return self._obj(osmid, data) * * cdef object _get_cur(self): # <<<<<<<<<<<<<< * """ * Return the current object at the current cursor position */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("imposm.cache.tc.BDB._get_cur", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_value); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":207 * return osmid, value * * def close(self): # <<<<<<<<<<<<<< * if self._opened: * tcbdbclose(self.db) */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_23close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_3BDB_23close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_3BDB_22close(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_3BDB_22close(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("close", 0); /* "imposm/cache/tc.pyx":208 * * def close(self): * if self._opened: # <<<<<<<<<<<<<< * tcbdbclose(self.db) * self._opened = 0 */ __pyx_t_1 = (__pyx_v_self->_opened != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":209 * def close(self): * if self._opened: * tcbdbclose(self.db) # <<<<<<<<<<<<<< * self._opened = 0 * */ tcbdbclose(__pyx_v_self->db); goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":210 * if self._opened: * tcbdbclose(self.db) * self._opened = 0 # <<<<<<<<<<<<<< * * def __dealloc__(self): */ __pyx_v_self->_opened = 0; /* "imposm/cache/tc.pyx":207 * return osmid, value * * def close(self): # <<<<<<<<<<<<<< * if self._opened: * tcbdbclose(self.db) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":212 * self._opened = 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self._opened: * tcbdbclose(self.db) */ /* Python wrapper */ static void __pyx_pw_6imposm_5cache_2tc_3BDB_25__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_6imposm_5cache_2tc_3BDB_25__dealloc__(PyObject *__pyx_v_self) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); __pyx_pf_6imposm_5cache_2tc_3BDB_24__dealloc__(((struct __pyx_obj_6imposm_5cache_2tc_BDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); } static void __pyx_pf_6imposm_5cache_2tc_3BDB_24__dealloc__(struct __pyx_obj_6imposm_5cache_2tc_BDB *__pyx_v_self) { __Pyx_RefNannyDeclarations int __pyx_t_1; __Pyx_RefNannySetupContext("__dealloc__", 0); /* "imposm/cache/tc.pyx":213 * * def __dealloc__(self): * if self._opened: # <<<<<<<<<<<<<< * tcbdbclose(self.db) * tcbdbdel(self.db) */ __pyx_t_1 = (__pyx_v_self->_opened != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":214 * def __dealloc__(self): * if self._opened: * tcbdbclose(self.db) # <<<<<<<<<<<<<< * tcbdbdel(self.db) * */ tcbdbclose(__pyx_v_self->db); goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":215 * if self._opened: * tcbdbclose(self.db) * tcbdbdel(self.db) # <<<<<<<<<<<<<< * * cdef class CoordDB(BDB): */ tcbdbdel(__pyx_v_self->db); /* "imposm/cache/tc.pyx":212 * self._opened = 0 * * def __dealloc__(self): # <<<<<<<<<<<<<< * if self._opened: * tcbdbclose(self.db) */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "imposm/cache/tc.pyx":218 * * cdef class CoordDB(BDB): * def put(self, osmid, x, y): # <<<<<<<<<<<<<< * return self._put(osmid, x, y) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_osmid = 0; PyObject *__pyx_v_x = 0; PyObject *__pyx_v_y = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_x,&__pyx_n_s_y,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_osmid = values[0]; __pyx_v_x = values[1]; __pyx_v_y = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.CoordDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_7CoordDB_put(((struct __pyx_obj_6imposm_5cache_2tc_CoordDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_x, __pyx_v_y); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_put(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int64_t __pyx_t_1; double __pyx_t_2; double __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":219 * cdef class CoordDB(BDB): * def put(self, osmid, x, y): * return self._put(osmid, x, y) # <<<<<<<<<<<<<< * * def put_marshaled(self, osmid, x, y): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_As_int64_t(__pyx_v_osmid); if (unlikely((__pyx_t_1 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_x); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_y); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_4 = __Pyx_PyBool_FromLong(((struct __pyx_vtabstruct_6imposm_5cache_2tc_CoordDB *)__pyx_v_self->__pyx_base.__pyx_vtab)->_put(__pyx_v_self, __pyx_t_1, __pyx_t_2, __pyx_t_3)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":218 * * cdef class CoordDB(BDB): * def put(self, osmid, x, y): # <<<<<<<<<<<<<< * return self._put(osmid, x, y) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.CoordDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":221 * return self._put(osmid, x, y) * * def put_marshaled(self, osmid, x, y): # <<<<<<<<<<<<<< * return self._put(osmid, x, y) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_osmid = 0; PyObject *__pyx_v_x = 0; PyObject *__pyx_v_y = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put_marshaled (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_x,&__pyx_n_s_y,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put_marshaled") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_osmid = values[0]; __pyx_v_x = values[1]; __pyx_v_y = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.CoordDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_7CoordDB_2put_marshaled(((struct __pyx_obj_6imposm_5cache_2tc_CoordDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_x, __pyx_v_y); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_x, PyObject *__pyx_v_y) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int64_t __pyx_t_1; double __pyx_t_2; double __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put_marshaled", 0); /* "imposm/cache/tc.pyx":222 * * def put_marshaled(self, osmid, x, y): * return self._put(osmid, x, y) # <<<<<<<<<<<<<< * * cdef bint _put(self, int64_t osmid, double x, double y) nogil: */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_As_int64_t(__pyx_v_osmid); if (unlikely((__pyx_t_1 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_v_x); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_v_y); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_4 = __Pyx_PyBool_FromLong(((struct __pyx_vtabstruct_6imposm_5cache_2tc_CoordDB *)__pyx_v_self->__pyx_base.__pyx_vtab)->_put(__pyx_v_self, __pyx_t_1, __pyx_t_2, __pyx_t_3)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":221 * return self._put(osmid, x, y) * * def put_marshaled(self, osmid, x, y): # <<<<<<<<<<<<<< * return self._put(osmid, x, y) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.CoordDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":224 * return self._put(osmid, x, y) * * cdef bint _put(self, int64_t osmid, double x, double y) nogil: # <<<<<<<<<<<<<< * cdef coord p = coord_struct(x, y) * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) */ static int __pyx_f_6imposm_5cache_2tc_7CoordDB__put(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_x, double __pyx_v_y) { __pyx_t_6imposm_5cache_2tc_coord __pyx_v_p; int __pyx_r; /* "imposm/cache/tc.pyx":225 * * cdef bint _put(self, int64_t osmid, double x, double y) nogil: * cdef coord p = coord_struct(x, y) # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) * */ __pyx_v_p = __pyx_f_6imposm_5cache_2tc_coord_struct(__pyx_v_x, __pyx_v_y); /* "imposm/cache/tc.pyx":226 * cdef bint _put(self, int64_t osmid, double x, double y) nogil: * cdef coord p = coord_struct(x, y) * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) # <<<<<<<<<<<<<< * * def get(self, int64_t osmid): */ __pyx_r = tcbdbput(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), ((char *)(&__pyx_v_p)), (sizeof(__pyx_t_6imposm_5cache_2tc_coord))); goto __pyx_L0; /* "imposm/cache/tc.pyx":224 * return self._put(osmid, x, y) * * cdef bint _put(self, int64_t osmid, double x, double y) nogil: # <<<<<<<<<<<<<< * cdef coord p = coord_struct(x, y) * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "imposm/cache/tc.pyx":228 * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * cdef coord *value * cdef int ret_size */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_5get(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_5get(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid) { int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); assert(__pyx_arg_osmid); { __pyx_v_osmid = __Pyx_PyInt_As_int64_t(__pyx_arg_osmid); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 228; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.CoordDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_7CoordDB_4get(((struct __pyx_obj_6imposm_5cache_2tc_CoordDB *)__pyx_v_self), ((int64_t)__pyx_v_osmid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_4get(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid) { __pyx_t_6imposm_5cache_2tc_coord *__pyx_v_value; int __pyx_v_ret_size; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); /* "imposm/cache/tc.pyx":231 * cdef coord *value * cdef int ret_size * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) # <<<<<<<<<<<<<< * if not value: return * return _uint32_to_coord(value.x), _uint32_to_coord(value.y) */ __pyx_v_value = ((__pyx_t_6imposm_5cache_2tc_coord *)tcbdbget3(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), (&__pyx_v_ret_size))); /* "imposm/cache/tc.pyx":232 * cdef int ret_size * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return # <<<<<<<<<<<<<< * return _uint32_to_coord(value.x), _uint32_to_coord(value.y) * */ __pyx_t_1 = ((!(__pyx_v_value != 0)) != 0); if (__pyx_t_1) { __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "imposm/cache/tc.pyx":233 * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return * return _uint32_to_coord(value.x), _uint32_to_coord(value.y) # <<<<<<<<<<<<<< * * def get_coords(self, refs): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->x)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->y)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":228 * return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * cdef coord *value * cdef int ret_size */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.CoordDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":235 * return _uint32_to_coord(value.x), _uint32_to_coord(value.y) * * def get_coords(self, refs): # <<<<<<<<<<<<<< * cdef coord *value * cdef int ret_size */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_7get_coords(PyObject *__pyx_v_self, PyObject *__pyx_v_refs); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_7CoordDB_7get_coords(PyObject *__pyx_v_self, PyObject *__pyx_v_refs) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_coords (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_7CoordDB_6get_coords(((struct __pyx_obj_6imposm_5cache_2tc_CoordDB *)__pyx_v_self), ((PyObject *)__pyx_v_refs)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_7CoordDB_6get_coords(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, PyObject *__pyx_v_refs) { __pyx_t_6imposm_5cache_2tc_coord *__pyx_v_value; int __pyx_v_ret_size; int64_t __pyx_v_osmid; PyObject *__pyx_v_coords = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; int64_t __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_coords", 0); /* "imposm/cache/tc.pyx":239 * cdef int ret_size * cdef int64_t osmid * coords = list() # <<<<<<<<<<<<<< * for osmid in refs: * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_coords = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":240 * cdef int64_t osmid * coords = list() * for osmid in refs: # <<<<<<<<<<<<<< * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return */ if (likely(PyList_CheckExact(__pyx_v_refs)) || PyTuple_CheckExact(__pyx_v_refs)) { __pyx_t_1 = __pyx_v_refs; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_refs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif } } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } break; } __Pyx_GOTREF(__pyx_t_4); } __pyx_t_5 = __Pyx_PyInt_As_int64_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_osmid = __pyx_t_5; /* "imposm/cache/tc.pyx":241 * coords = list() * for osmid in refs: * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) # <<<<<<<<<<<<<< * if not value: return * coords.append((_uint32_to_coord(value.x), _uint32_to_coord(value.y))) */ __pyx_v_value = ((__pyx_t_6imposm_5cache_2tc_coord *)tcbdbget3(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), (&__pyx_v_ret_size))); /* "imposm/cache/tc.pyx":242 * for osmid in refs: * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return # <<<<<<<<<<<<<< * coords.append((_uint32_to_coord(value.x), _uint32_to_coord(value.y))) * */ __pyx_t_6 = ((!(__pyx_v_value != 0)) != 0); if (__pyx_t_6) { __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } /* "imposm/cache/tc.pyx":243 * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return * coords.append((_uint32_to_coord(value.x), _uint32_to_coord(value.y))) # <<<<<<<<<<<<<< * * return coords */ __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->x)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->y)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_coords, __pyx_t_8); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "imposm/cache/tc.pyx":240 * cdef int64_t osmid * coords = list() * for osmid in refs: # <<<<<<<<<<<<<< * value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) * if not value: return */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":245 * coords.append((_uint32_to_coord(value.x), _uint32_to_coord(value.y))) * * return coords # <<<<<<<<<<<<<< * * cdef object _get_cur(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_coords); __pyx_r = __pyx_v_coords; goto __pyx_L0; /* "imposm/cache/tc.pyx":235 * return _uint32_to_coord(value.x), _uint32_to_coord(value.y) * * def get_coords(self, refs): # <<<<<<<<<<<<<< * cdef coord *value * cdef int ret_size */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("imposm.cache.tc.CoordDB.get_coords", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_coords); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":247 * return coords * * cdef object _get_cur(self): # <<<<<<<<<<<<<< * cdef int size * cdef int64_t osmid */ static PyObject *__pyx_f_6imposm_5cache_2tc_7CoordDB__get_cur(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self) { int __pyx_v_size; int64_t __pyx_v_osmid; void *__pyx_v_ret; __pyx_t_6imposm_5cache_2tc_coord *__pyx_v_value; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get_cur", 0); /* "imposm/cache/tc.pyx":252 * cdef void *ret * cdef coord *value * ret = tcbdbcurkey3(self._cur, &size) # <<<<<<<<<<<<<< * osmid = (ret)[0] * value = tcbdbcurval3(self._cur, &size) */ __pyx_v_ret = tcbdbcurkey3(__pyx_v_self->__pyx_base._cur, (&__pyx_v_size)); /* "imposm/cache/tc.pyx":253 * cdef coord *value * ret = tcbdbcurkey3(self._cur, &size) * osmid = (ret)[0] # <<<<<<<<<<<<<< * value = tcbdbcurval3(self._cur, &size) * return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) */ __pyx_v_osmid = (((int64_t *)__pyx_v_ret)[0]); /* "imposm/cache/tc.pyx":254 * ret = tcbdbcurkey3(self._cur, &size) * osmid = (ret)[0] * value = tcbdbcurval3(self._cur, &size) # <<<<<<<<<<<<<< * return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) * */ __pyx_v_value = ((__pyx_t_6imposm_5cache_2tc_coord *)tcbdbcurval3(__pyx_v_self->__pyx_base._cur, (&__pyx_v_size))); /* "imposm/cache/tc.pyx":255 * osmid = (ret)[0] * value = tcbdbcurval3(self._cur, &size) * return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) # <<<<<<<<<<<<<< * * cdef object _obj(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->x)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_value->y)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":247 * return coords * * cdef object _get_cur(self): # <<<<<<<<<<<<<< * cdef int size * cdef int64_t osmid */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.CoordDB._get_cur", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":257 * return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return osmid, data * */ static PyObject *__pyx_f_6imposm_5cache_2tc_7CoordDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_CoordDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_obj", 0); /* "imposm/cache/tc.pyx":258 * * cdef object _obj(self, int64_t osmid, data): * return osmid, data # <<<<<<<<<<<<<< * * cdef class NodeDB(BDB): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":257 * return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return osmid, data * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("imposm.cache.tc.CoordDB._obj", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":261 * * cdef class NodeDB(BDB): * def put(self, osmid, tags, pos): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_6NodeDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_6NodeDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_osmid = 0; PyObject *__pyx_v_tags = 0; PyObject *__pyx_v_pos = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_tags,&__pyx_n_s_pos,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tags)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pos)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_osmid = values[0]; __pyx_v_tags = values[1]; __pyx_v_pos = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.NodeDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_6NodeDB_put(((struct __pyx_obj_6imposm_5cache_2tc_NodeDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_tags, __pyx_v_pos); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_6NodeDB_put(struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_tags, PyObject *__pyx_v_pos) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":262 * cdef class NodeDB(BDB): * def put(self, osmid, tags, pos): * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) # <<<<<<<<<<<<<< * * def put_marshaled(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_put_marshaled); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_tags); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_tags); __Pyx_GIVEREF(__pyx_v_tags); __Pyx_INCREF(__pyx_v_pos); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_pos); __Pyx_GIVEREF(__pyx_v_pos); __pyx_t_4 = PyMarshal_WriteObjectToString(__pyx_t_3, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_5 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_3) { PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_osmid); __Pyx_GIVEREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":261 * * cdef class NodeDB(BDB): * def put(self, osmid, tags, pos): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("imposm.cache.tc.NodeDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":264 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_6NodeDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_6NodeDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64_t __pyx_v_osmid; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put_marshaled (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put_marshaled") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.NodeDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_6NodeDB_2put_marshaled(((struct __pyx_obj_6imposm_5cache_2tc_NodeDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_6NodeDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations char *__pyx_t_1; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put_marshaled", 0); /* "imposm/cache/tc.pyx":265 * * def put_marshaled(self, int64_t osmid, data): * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) # <<<<<<<<<<<<<< * * cdef object _obj(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_data); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyBool_FromLong(tcbdbput(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), ((char *)__pyx_t_1), __pyx_t_2)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":264 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.NodeDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":267 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Node(osmid, data[0], data[1]) * */ static PyObject *__pyx_f_6imposm_5cache_2tc_6NodeDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_NodeDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_obj", 0); /* "imposm/cache/tc.pyx":268 * * cdef object _obj(self, int64_t osmid, data): * return Node(osmid, data[0], data[1]) # <<<<<<<<<<<<<< * * cdef class InsertedWayDB(BDB): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Node); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_data, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_data, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":267 * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Node(osmid, data[0], data[1]) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("imposm.cache.tc.NodeDB._obj", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":271 * * cdef class InsertedWayDB(BDB): * def put(self, int64_t osmid): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_arg_osmid) { int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); assert(__pyx_arg_osmid); { __pyx_v_osmid = __Pyx_PyInt_As_int64_t(__pyx_arg_osmid); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.InsertedWayDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_put(((struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *)__pyx_v_self), ((int64_t)__pyx_v_osmid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_put(struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *__pyx_v_self, int64_t __pyx_v_osmid) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":272 * cdef class InsertedWayDB(BDB): * def put(self, int64_t osmid): * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); # <<<<<<<<<<<<<< * * def __next__(self): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(tcbdbput(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), __pyx_k_x, 1)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":271 * * cdef class InsertedWayDB(BDB): * def put(self, int64_t osmid): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("imposm.cache.tc.InsertedWayDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":274 * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); * * def __next__(self): # <<<<<<<<<<<<<< * """ * Return next item as object. */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_3__next__(PyObject *__pyx_v_self); /*proto*/ static char __pyx_doc_6imposm_5cache_2tc_13InsertedWayDB_2__next__[] = "\n Return next item as object.\n "; #if CYTHON_COMPILING_IN_CPYTHON struct wrapperbase __pyx_wrapperbase_6imposm_5cache_2tc_13InsertedWayDB_2__next__; #endif static PyObject *__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_3__next__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_2__next__(((struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13InsertedWayDB_2__next__(struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *__pyx_v_self) { int64_t __pyx_v_osmid; int __pyx_v_size; void *__pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__next__", 0); /* "imposm/cache/tc.pyx":282 * cdef void *ret * * if not self._cur: raise StopIteration # <<<<<<<<<<<<<< * * ret = tcbdbcurkey3(self._cur, &size) */ __pyx_t_1 = ((!(__pyx_v_self->__pyx_base._cur != 0)) != 0); if (__pyx_t_1) { __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "imposm/cache/tc.pyx":284 * if not self._cur: raise StopIteration * * ret = tcbdbcurkey3(self._cur, &size) # <<<<<<<<<<<<<< * osmid = (ret)[0] * */ __pyx_v_ret = tcbdbcurkey3(__pyx_v_self->__pyx_base._cur, (&__pyx_v_size)); /* "imposm/cache/tc.pyx":285 * * ret = tcbdbcurkey3(self._cur, &size) * osmid = (ret)[0] # <<<<<<<<<<<<<< * * # advance cursor, set to NULL if at the end */ __pyx_v_osmid = (((int64_t *)__pyx_v_ret)[0]); /* "imposm/cache/tc.pyx":288 * * # advance cursor, set to NULL if at the end * if tcbdbcurnext(self._cur) == 0: # <<<<<<<<<<<<<< * tcbdbcurdel(self._cur) * self._cur = NULL */ __pyx_t_1 = ((tcbdbcurnext(__pyx_v_self->__pyx_base._cur) == 0) != 0); if (__pyx_t_1) { /* "imposm/cache/tc.pyx":289 * # advance cursor, set to NULL if at the end * if tcbdbcurnext(self._cur) == 0: * tcbdbcurdel(self._cur) # <<<<<<<<<<<<<< * self._cur = NULL * */ tcbdbcurdel(__pyx_v_self->__pyx_base._cur); /* "imposm/cache/tc.pyx":290 * if tcbdbcurnext(self._cur) == 0: * tcbdbcurdel(self._cur) * self._cur = NULL # <<<<<<<<<<<<<< * * return osmid */ __pyx_v_self->__pyx_base._cur = NULL; goto __pyx_L4; } __pyx_L4:; /* "imposm/cache/tc.pyx":292 * self._cur = NULL * * return osmid # <<<<<<<<<<<<<< * * cdef class RefTagDB(BDB): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 292; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":274 * return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); * * def __next__(self): # <<<<<<<<<<<<<< * """ * Return next item as object. */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("imposm.cache.tc.InsertedWayDB.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":298 * Database for items with references and tags (i.e. ways/relations). * """ * def put(self, osmid, tags, refs): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_8RefTagDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_8RefTagDB_1put(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_osmid = 0; PyObject *__pyx_v_tags = 0; PyObject *__pyx_v_refs = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_tags,&__pyx_n_s_refs,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tags)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_refs)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_osmid = values[0]; __pyx_v_tags = values[1]; __pyx_v_refs = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.RefTagDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_8RefTagDB_put(((struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_tags, __pyx_v_refs); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_8RefTagDB_put(struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *__pyx_v_self, PyObject *__pyx_v_osmid, PyObject *__pyx_v_tags, PyObject *__pyx_v_refs) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; Py_ssize_t __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":299 * """ * def put(self, osmid, tags, refs): * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) # <<<<<<<<<<<<<< * * def put_marshaled(self, int64_t osmid, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_put_marshaled); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_tags); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_tags); __Pyx_GIVEREF(__pyx_v_tags); __Pyx_INCREF(__pyx_v_refs); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_refs); __Pyx_GIVEREF(__pyx_v_refs); __pyx_t_4 = PyMarshal_WriteObjectToString(__pyx_t_3, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_5 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_3) { PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_v_osmid); __Pyx_GIVEREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":298 * Database for items with references and tags (i.e. ways/relations). * """ * def put(self, osmid, tags, refs): # <<<<<<<<<<<<<< * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("imposm.cache.tc.RefTagDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":301 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_8RefTagDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyObject *__pyx_pw_6imposm_5cache_2tc_8RefTagDB_3put_marshaled(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int64_t __pyx_v_osmid; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put_marshaled (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_osmid,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put_marshaled") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[0]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put_marshaled", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.RefTagDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_8RefTagDB_2put_marshaled(((struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *)__pyx_v_self), __pyx_v_osmid, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_8RefTagDB_2put_marshaled(struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations char *__pyx_t_1; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put_marshaled", 0); /* "imposm/cache/tc.pyx":302 * * def put_marshaled(self, int64_t osmid, data): * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) # <<<<<<<<<<<<<< * * cdef class WayDB(RefTagDB): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_AsString(__pyx_v_data); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyBool_FromLong(tcbdbput(__pyx_v_self->__pyx_base.db, ((char *)(&__pyx_v_osmid)), (sizeof(int64_t)), ((char *)__pyx_t_1), __pyx_t_2)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 302; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":301 * return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) * * def put_marshaled(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.RefTagDB.put_marshaled", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":305 * * cdef class WayDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Way(osmid, data[0], data[1]) * */ static PyObject *__pyx_f_6imposm_5cache_2tc_5WayDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_WayDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_obj", 0); /* "imposm/cache/tc.pyx":306 * cdef class WayDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): * return Way(osmid, data[0], data[1]) # <<<<<<<<<<<<<< * * cdef class RelationDB(RefTagDB): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Way); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_data, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_data, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 306; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":305 * * cdef class WayDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Way(osmid, data[0], data[1]) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("imposm.cache.tc.WayDB._obj", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":309 * * cdef class RelationDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Relation(osmid, data[0], data[1]) * */ static PyObject *__pyx_f_6imposm_5cache_2tc_10RelationDB__obj(CYTHON_UNUSED struct __pyx_obj_6imposm_5cache_2tc_RelationDB *__pyx_v_self, int64_t __pyx_v_osmid, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_obj", 0); /* "imposm/cache/tc.pyx":310 * cdef class RelationDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): * return Relation(osmid, data[0], data[1]) # <<<<<<<<<<<<<< * * from imposm.cache.internal import DeltaCoords as _DeltaCoords */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Relation); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_data, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_data, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":309 * * cdef class RelationDB(RefTagDB): * cdef object _obj(self, int64_t osmid, data): # <<<<<<<<<<<<<< * return Relation(osmid, data[0], data[1]) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("imposm.cache.tc.RelationDB._obj", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":316 * import bisect * * cdef unzip_nodes(list nodes): # <<<<<<<<<<<<<< * cdef int64_t last_lon, last_lat, lon, lat * cdef double lon_f, lat_f */ static PyObject *__pyx_f_6imposm_5cache_2tc_unzip_nodes(PyObject *__pyx_v_nodes) { int64_t __pyx_v_last_lon; int64_t __pyx_v_last_lat; int64_t __pyx_v_lon; int64_t __pyx_v_lat; double __pyx_v_lon_f; double __pyx_v_lat_f; int64_t __pyx_v_last_id; int64_t __pyx_v_id; PyObject *__pyx_v_ids = NULL; PyObject *__pyx_v_lons = NULL; PyObject *__pyx_v_lats = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); int64_t __pyx_t_9; double __pyx_t_10; double __pyx_t_11; int __pyx_t_12; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("unzip_nodes", 0); /* "imposm/cache/tc.pyx":320 * cdef double lon_f, lat_f * cdef int64_t last_id, id * ids, lons, lats = [], [], [] # <<<<<<<<<<<<<< * last_id = last_lon = last_lat = 0 * for id, lon_f, lat_f in nodes: */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 320; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 320; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 320; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_v_ids = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; __pyx_v_lons = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; __pyx_v_lats = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; /* "imposm/cache/tc.pyx":321 * cdef int64_t last_id, id * ids, lons, lats = [], [], [] * last_id = last_lon = last_lat = 0 # <<<<<<<<<<<<<< * for id, lon_f, lat_f in nodes: * lon = _coord_to_uint32(lon_f) */ __pyx_v_last_id = 0; __pyx_v_last_lon = 0; __pyx_v_last_lat = 0; /* "imposm/cache/tc.pyx":322 * ids, lons, lats = [], [], [] * last_id = last_lon = last_lat = 0 * for id, lon_f, lat_f in nodes: # <<<<<<<<<<<<<< * lon = _coord_to_uint32(lon_f) * lat = _coord_to_uint32(lat_f) */ if (unlikely(__pyx_v_nodes == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_3 = __pyx_v_nodes; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0; for (;;) { if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_1 = PyList_GET_ITEM(sequence, 0); __pyx_t_5 = PyList_GET_ITEM(sequence, 1); __pyx_t_6 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); #else __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; index = 0; __pyx_t_1 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); index = 1; __pyx_t_5 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_5); index = 2; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L6_unpacking_done; __pyx_L5_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_L6_unpacking_done:; } __pyx_t_9 = __Pyx_PyInt_As_int64_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_11 = __pyx_PyFloat_AsDouble(__pyx_t_6); if (unlikely((__pyx_t_11 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 322; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_id = __pyx_t_9; __pyx_v_lon_f = __pyx_t_10; __pyx_v_lat_f = __pyx_t_11; /* "imposm/cache/tc.pyx":323 * last_id = last_lon = last_lat = 0 * for id, lon_f, lat_f in nodes: * lon = _coord_to_uint32(lon_f) # <<<<<<<<<<<<<< * lat = _coord_to_uint32(lat_f) * */ __pyx_v_lon = __pyx_f_6imposm_5cache_2tc__coord_to_uint32(__pyx_v_lon_f); /* "imposm/cache/tc.pyx":324 * for id, lon_f, lat_f in nodes: * lon = _coord_to_uint32(lon_f) * lat = _coord_to_uint32(lat_f) # <<<<<<<<<<<<<< * * ids.append(id - last_id) */ __pyx_v_lat = __pyx_f_6imposm_5cache_2tc__coord_to_uint32(__pyx_v_lat_f); /* "imposm/cache/tc.pyx":326 * lat = _coord_to_uint32(lat_f) * * ids.append(id - last_id) # <<<<<<<<<<<<<< * lons.append(lon - last_lon) * lats.append(lat - last_lat) */ __pyx_t_2 = __Pyx_PyInt_From_int64_t((__pyx_v_id - __pyx_v_last_id)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 326; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_ids, __pyx_t_2); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 326; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":327 * * ids.append(id - last_id) * lons.append(lon - last_lon) # <<<<<<<<<<<<<< * lats.append(lat - last_lat) * last_id = id */ __pyx_t_2 = __Pyx_PyInt_From_int64_t((__pyx_v_lon - __pyx_v_last_lon)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_lons, __pyx_t_2); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":328 * ids.append(id - last_id) * lons.append(lon - last_lon) * lats.append(lat - last_lat) # <<<<<<<<<<<<<< * last_id = id * last_lon = lon */ __pyx_t_2 = __Pyx_PyInt_From_int64_t((__pyx_v_lat - __pyx_v_last_lat)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_lats, __pyx_t_2); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":329 * lons.append(lon - last_lon) * lats.append(lat - last_lat) * last_id = id # <<<<<<<<<<<<<< * last_lon = lon * last_lat = lat */ __pyx_v_last_id = __pyx_v_id; /* "imposm/cache/tc.pyx":330 * lats.append(lat - last_lat) * last_id = id * last_lon = lon # <<<<<<<<<<<<<< * last_lat = lat * */ __pyx_v_last_lon = __pyx_v_lon; /* "imposm/cache/tc.pyx":331 * last_id = id * last_lon = lon * last_lat = lat # <<<<<<<<<<<<<< * * return ids, lons, lats */ __pyx_v_last_lat = __pyx_v_lat; /* "imposm/cache/tc.pyx":322 * ids, lons, lats = [], [], [] * last_id = last_lon = last_lat = 0 * for id, lon_f, lat_f in nodes: # <<<<<<<<<<<<<< * lon = _coord_to_uint32(lon_f) * lat = _coord_to_uint32(lat_f) */ } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "imposm/cache/tc.pyx":333 * last_lat = lat * * return ids, lons, lats # <<<<<<<<<<<<<< * * cdef zip_nodes(tuple ids, tuple lons, tuple lats): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_ids); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_ids); __Pyx_GIVEREF(__pyx_v_ids); __Pyx_INCREF(__pyx_v_lons); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_lons); __Pyx_GIVEREF(__pyx_v_lons); __Pyx_INCREF(__pyx_v_lats); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_lats); __Pyx_GIVEREF(__pyx_v_lats); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":316 * import bisect * * cdef unzip_nodes(list nodes): # <<<<<<<<<<<<<< * cdef int64_t last_lon, last_lat, lon, lat * cdef double lon_f, lat_f */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("imposm.cache.tc.unzip_nodes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ids); __Pyx_XDECREF(__pyx_v_lons); __Pyx_XDECREF(__pyx_v_lats); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":335 * return ids, lons, lats * * cdef zip_nodes(tuple ids, tuple lons, tuple lats): # <<<<<<<<<<<<<< * cdef uint32_t last_lon, last_lat * cdef int64_t last_id */ static PyObject *__pyx_f_6imposm_5cache_2tc_zip_nodes(PyObject *__pyx_v_ids, PyObject *__pyx_v_lons, PyObject *__pyx_v_lats) { uint32_t __pyx_v_last_lon; uint32_t __pyx_v_last_lat; int64_t __pyx_v_last_id; PyObject *__pyx_v_nodes = NULL; Py_ssize_t __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int64_t __pyx_t_6; uint32_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("zip_nodes", 0); /* "imposm/cache/tc.pyx":338 * cdef uint32_t last_lon, last_lat * cdef int64_t last_id * nodes = [] # <<<<<<<<<<<<<< * last_id = last_lon = last_lat = 0 * */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 338; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_nodes = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":339 * cdef int64_t last_id * nodes = [] * last_id = last_lon = last_lat = 0 # <<<<<<<<<<<<<< * * for i in range(len(ids)): */ __pyx_v_last_id = 0; __pyx_v_last_lon = 0; __pyx_v_last_lat = 0; /* "imposm/cache/tc.pyx":341 * last_id = last_lon = last_lat = 0 * * for i in range(len(ids)): # <<<<<<<<<<<<<< * last_id += ids[i] * last_lon += lons[i] */ if (unlikely(__pyx_v_ids == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_2 = PyTuple_GET_SIZE(__pyx_v_ids); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { __pyx_v_i = __pyx_t_3; /* "imposm/cache/tc.pyx":342 * * for i in range(len(ids)): * last_id += ids[i] # <<<<<<<<<<<<<< * last_lon += lons[i] * last_lat += lats[i] */ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_last_id); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (unlikely(__pyx_v_ids == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_ids, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = __Pyx_PyInt_As_int64_t(__pyx_t_5); if (unlikely((__pyx_t_6 == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_last_id = __pyx_t_6; /* "imposm/cache/tc.pyx":343 * for i in range(len(ids)): * last_id += ids[i] * last_lon += lons[i] # <<<<<<<<<<<<<< * last_lat += lats[i] * */ __pyx_t_5 = __Pyx_PyInt_From_uint32_t(__pyx_v_last_lon); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (unlikely(__pyx_v_lons == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_lons, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (uint32_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_last_lon = __pyx_t_7; /* "imposm/cache/tc.pyx":344 * last_id += ids[i] * last_lon += lons[i] * last_lat += lats[i] # <<<<<<<<<<<<<< * * nodes.append(( */ __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_last_lat); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (unlikely(__pyx_v_lats == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_lats, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __Pyx_PyInt_As_uint32_t(__pyx_t_5); if (unlikely((__pyx_t_7 == (uint32_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_last_lat = __pyx_t_7; /* "imposm/cache/tc.pyx":347 * * nodes.append(( * last_id, # <<<<<<<<<<<<<< * _uint32_to_coord(last_lon), * _uint32_to_coord(last_lat) */ __pyx_t_5 = __Pyx_PyInt_From_int64_t(__pyx_v_last_id); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 347; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); /* "imposm/cache/tc.pyx":348 * nodes.append(( * last_id, * _uint32_to_coord(last_lon), # <<<<<<<<<<<<<< * _uint32_to_coord(last_lat) * )) */ __pyx_t_4 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_last_lon)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 348; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); /* "imposm/cache/tc.pyx":349 * last_id, * _uint32_to_coord(last_lon), * _uint32_to_coord(last_lat) # <<<<<<<<<<<<<< * )) * return nodes */ __pyx_t_1 = PyFloat_FromDouble(__pyx_f_6imposm_5cache_2tc__uint32_to_coord(__pyx_v_last_lat)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "imposm/cache/tc.pyx":347 * * nodes.append(( * last_id, # <<<<<<<<<<<<<< * _uint32_to_coord(last_lon), * _uint32_to_coord(last_lat) */ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 347; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":346 * last_lat += lats[i] * * nodes.append(( # <<<<<<<<<<<<<< * last_id, * _uint32_to_coord(last_lon), */ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_nodes, __pyx_t_8); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } /* "imposm/cache/tc.pyx":351 * _uint32_to_coord(last_lat) * )) * return nodes # <<<<<<<<<<<<<< * * class DeltaNodes(object): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_nodes); __pyx_r = __pyx_v_nodes; goto __pyx_L0; /* "imposm/cache/tc.pyx":335 * return ids, lons, lats * * cdef zip_nodes(tuple ids, tuple lons, tuple lats): # <<<<<<<<<<<<<< * cdef uint32_t last_lon, last_lat * cdef int64_t last_id */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("imposm.cache.tc.zip_nodes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_nodes); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":354 * * class DeltaNodes(object): * def __init__(self, data=None): # <<<<<<<<<<<<<< * self.nodes = [] * self.changed = False */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)((PyObject *)Py_None)); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_self = values[0]; __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes___init__(__pyx_self, __pyx_v_self, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "imposm/cache/tc.pyx":355 * class DeltaNodes(object): * def __init__(self, data=None): * self.nodes = [] # <<<<<<<<<<<<<< * self.changed = False * if data: */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_nodes, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 355; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":356 * def __init__(self, data=None): * self.nodes = [] * self.changed = False # <<<<<<<<<<<<<< * if data: * self.deserialize(data) */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_changed, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 356; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":357 * self.nodes = [] * self.changed = False * if data: # <<<<<<<<<<<<<< * self.deserialize(data) * */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_data); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 357; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_2) { /* "imposm/cache/tc.pyx":358 * self.changed = False * if data: * self.deserialize(data) # <<<<<<<<<<<<<< * * def changed(self): */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_deserialize); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":354 * * class DeltaNodes(object): * def __init__(self, data=None): # <<<<<<<<<<<<<< * self.nodes = [] * self.changed = False */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":360 * self.deserialize(data) * * def changed(self): # <<<<<<<<<<<<<< * return self.changed * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_3changed(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_3changed = {"changed", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_3changed, METH_O, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_3changed(PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("changed (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes_2changed(__pyx_self, ((PyObject *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_2changed(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("changed", 0); /* "imposm/cache/tc.pyx":361 * * def changed(self): * return self.changed # <<<<<<<<<<<<<< * * def get(self, int64_t osmid): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_changed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":360 * self.deserialize(data) * * def changed(self): # <<<<<<<<<<<<<< * return self.changed * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.changed", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":363 * return self.changed * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_5get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_5get = {"get", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_5get, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_5get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; int64_t __pyx_v_osmid; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_osmid,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("get", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes_4get(__pyx_self, __pyx_v_self, __pyx_v_osmid); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_4get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid) { PyObject *__pyx_v_i = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); /* "imposm/cache/tc.pyx":364 * * def get(self, int64_t osmid): * i = bisect.bisect(self.nodes, (osmid, )) # <<<<<<<<<<<<<< * if i != len(self.nodes) and self.nodes[i][0] == osmid: * return self.nodes[i][1:] */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_bisect); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_bisect); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_4) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_2 = 0; __pyx_t_5 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_i = __pyx_t_1; __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":365 * def get(self, int64_t osmid): * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: # <<<<<<<<<<<<<< * return self.nodes[i][1:] * return None */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_RichCompare(__pyx_v_i, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyObject_GetItem(__pyx_t_3, __pyx_v_i); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L4_bool_binop_done:; if (__pyx_t_8) { /* "imposm/cache/tc.pyx":366 * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: * return self.nodes[i][1:] # <<<<<<<<<<<<<< * return None * */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = PyObject_GetItem(__pyx_t_7, __pyx_v_i); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice_, 1, 0, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L0; } /* "imposm/cache/tc.pyx":367 * if i != len(self.nodes) and self.nodes[i][0] == osmid: * return self.nodes[i][1:] * return None # <<<<<<<<<<<<<< * * def add(self, int64_t osmid, double lon, double lat): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; /* "imposm/cache/tc.pyx":363 * return self.changed * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_i); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":369 * return None * * def add(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * # todo: overwrite * self.changed = True */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_7add(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_7add = {"add", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_7add, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_7add(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; int64_t __pyx_v_osmid; double __pyx_v_lon; double __pyx_v_lat; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_osmid,&__pyx_n_s_lon,&__pyx_n_s_lat,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lon)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lat)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_self = values[0]; __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_lon = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_lon == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_lat = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_lat == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("add", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes_6add(__pyx_self, __pyx_v_self, __pyx_v_osmid, __pyx_v_lon, __pyx_v_lat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_6add(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_lon, double __pyx_v_lat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; Py_ssize_t __pyx_t_11; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("add", 0); /* "imposm/cache/tc.pyx":371 * def add(self, int64_t osmid, double lon, double lat): * # todo: overwrite * self.changed = True # <<<<<<<<<<<<<< * if self.nodes and self.nodes[-1][0] < osmid: * self.nodes.append((osmid, lon, lat)) */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_changed, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 371; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":372 * # todo: overwrite * self.changed = True * if self.nodes and self.nodes[-1][0] < osmid: # <<<<<<<<<<<<<< * self.nodes.append((osmid, lon, lat)) * else: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, -1, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "imposm/cache/tc.pyx":373 * self.changed = True * if self.nodes and self.nodes[-1][0] < osmid: * self.nodes.append((osmid, lon, lat)) # <<<<<<<<<<<<<< * else: * bisect.insort(self.nodes, (osmid, lon, lat)) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = PyFloat_FromDouble(__pyx_v_lon); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = PyFloat_FromDouble(__pyx_v_lat); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_6 = 0; __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_5, __pyx_t_7); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L3; } /*else*/ { /* "imposm/cache/tc.pyx":375 * self.nodes.append((osmid, lon, lat)) * else: * bisect.insort(self.nodes, (osmid, lon, lat)) # <<<<<<<<<<<<<< * * def serialize(self): */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_bisect); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_insort); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyFloat_FromDouble(__pyx_v_lon); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = PyFloat_FromDouble(__pyx_v_lat); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = PyTuple_New(3); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_9 = 0; __pyx_t_9 = NULL; __pyx_t_11 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_11 = 1; } } __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_9) { PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; } PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_11, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_5 = 0; __pyx_t_10 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __pyx_L3:; /* "imposm/cache/tc.pyx":369 * return None * * def add(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * # todo: overwrite * self.changed = True */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":377 * bisect.insort(self.nodes, (osmid, lon, lat)) * * def serialize(self): # <<<<<<<<<<<<<< * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_9serialize(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_9serialize = {"serialize", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_9serialize, METH_O, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_9serialize(PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("serialize (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes_8serialize(__pyx_self, ((PyObject *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_8serialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_ids = NULL; PyObject *__pyx_v_lons = NULL; PyObject *__pyx_v_lats = NULL; PyObject *__pyx_v_nodes = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *(*__pyx_t_6)(PyObject *); int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("serialize", 0); /* "imposm/cache/tc.pyx":378 * * def serialize(self): * ids, lons, lats = unzip_nodes(self.nodes) # <<<<<<<<<<<<<< * nodes = _DeltaCoords() * nodes.ids = ids */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_nodes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "list", Py_TYPE(__pyx_t_1)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_f_6imposm_5cache_2tc_unzip_nodes(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { PyObject* sequence = __pyx_t_2; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_4 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_1 = PyList_GET_ITEM(sequence, 0); __pyx_t_3 = PyList_GET_ITEM(sequence, 1); __pyx_t_4 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext; index = 0; __pyx_t_1 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); index = 1; __pyx_t_3 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_4); if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_6 = NULL; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L4_unpacking_done; __pyx_L3_unpacking_failed:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 378; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_L4_unpacking_done:; } __pyx_v_ids = __pyx_t_1; __pyx_t_1 = 0; __pyx_v_lons = __pyx_t_3; __pyx_t_3 = 0; __pyx_v_lats = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":379 * def serialize(self): * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() # <<<<<<<<<<<<<< * nodes.ids = ids * nodes.lons = lons */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_DeltaCoords); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (__pyx_t_3) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_nodes = __pyx_t_2; __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":380 * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() * nodes.ids = ids # <<<<<<<<<<<<<< * nodes.lons = lons * nodes.lats = lats */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_nodes, __pyx_n_s_ids, __pyx_v_ids) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":381 * nodes = _DeltaCoords() * nodes.ids = ids * nodes.lons = lons # <<<<<<<<<<<<<< * nodes.lats = lats * return nodes.SerializeToString() */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_nodes, __pyx_n_s_lons, __pyx_v_lons) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 381; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":382 * nodes.ids = ids * nodes.lons = lons * nodes.lats = lats # <<<<<<<<<<<<<< * return nodes.SerializeToString() * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_nodes, __pyx_n_s_lats, __pyx_v_lats) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":383 * nodes.lons = lons * nodes.lats = lats * return nodes.SerializeToString() # <<<<<<<<<<<<<< * * def deserialize(self, data): */ __Pyx_XDECREF(__pyx_r); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nodes, __pyx_n_s_SerializeToString); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (__pyx_t_3) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":377 * bisect.insort(self.nodes, (osmid, lon, lat)) * * def serialize(self): # <<<<<<<<<<<<<< * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.serialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ids); __Pyx_XDECREF(__pyx_v_lons); __Pyx_XDECREF(__pyx_v_lats); __Pyx_XDECREF(__pyx_v_nodes); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":385 * return nodes.SerializeToString() * * def deserialize(self, data): # <<<<<<<<<<<<<< * nodes = _DeltaCoords() * nodes.ParseFromString(data) */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_11deserialize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_11deserialize = {"deserialize", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_11deserialize, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_10DeltaNodes_11deserialize(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("deserialize (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_data,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("deserialize", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "deserialize") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_data = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("deserialize", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.deserialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_10DeltaNodes_10deserialize(__pyx_self, __pyx_v_self, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_10DeltaNodes_10deserialize(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data) { PyObject *__pyx_v_nodes = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("deserialize", 0); /* "imposm/cache/tc.pyx":386 * * def deserialize(self, data): * nodes = _DeltaCoords() # <<<<<<<<<<<<<< * nodes.ParseFromString(data) * self.nodes = zip_nodes( */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_DeltaCoords); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 386; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 386; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 386; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_nodes = __pyx_t_1; __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":387 * def deserialize(self, data): * nodes = _DeltaCoords() * nodes.ParseFromString(data) # <<<<<<<<<<<<<< * self.nodes = zip_nodes( * nodes.ids, nodes.lons, nodes.lats) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_nodes, __pyx_n_s_ParseFromString); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; __Pyx_INCREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":389 * nodes.ParseFromString(data) * self.nodes = zip_nodes( * nodes.ids, nodes.lons, nodes.lats) # <<<<<<<<<<<<<< * * class DeltaCoordsDB(object): */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_nodes, __pyx_n_s_ids); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_1)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_nodes, __pyx_n_s_lons); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (!(likely(PyTuple_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nodes, __pyx_n_s_lats); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (!(likely(PyTuple_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_4)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 389; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":388 * nodes = _DeltaCoords() * nodes.ParseFromString(data) * self.nodes = zip_nodes( # <<<<<<<<<<<<<< * nodes.ids, nodes.lons, nodes.lats) * */ __pyx_t_3 = __pyx_f_6imposm_5cache_2tc_zip_nodes(((PyObject*)__pyx_t_1), ((PyObject*)__pyx_t_2), ((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_nodes, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "imposm/cache/tc.pyx":385 * return nodes.SerializeToString() * * def deserialize(self, data): # <<<<<<<<<<<<<< * nodes = _DeltaCoords() * nodes.ParseFromString(data) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("imposm.cache.tc.DeltaNodes.deserialize", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_nodes); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":392 * * class DeltaCoordsDB(object): * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): # <<<<<<<<<<<<<< * self.db = BDB(filename, mode, estimated_records) * self.mode = mode */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_1__init__ = {"__init__", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_filename = 0; PyObject *__pyx_v_mode = 0; PyObject *__pyx_v_estimated_records = 0; PyObject *__pyx_v_delta_nodes_cache_size = 0; PyObject *__pyx_v_delta_nodes_size = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_filename,&__pyx_n_s_mode,&__pyx_n_s_estimated_records,&__pyx_n_s_delta_nodes_cache_size,&__pyx_n_s_delta_nodes_size,0}; PyObject* values[6] = {0,0,0,0,0,0}; values[2] = ((PyObject *)((PyObject*)__pyx_n_s_w)); values[3] = ((PyObject *)((PyObject *)__pyx_int_0)); values[4] = ((PyObject *)((PyObject *)__pyx_int_100)); values[5] = ((PyObject *)((PyObject *)__pyx_int_6)); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filename)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 6, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mode); if (value) { values[2] = value; kw_args--; } } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_estimated_records); if (value) { values[3] = value; kw_args--; } } case 4: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_nodes_cache_size); if (value) { values[4] = value; kw_args--; } } case 5: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_nodes_size); if (value) { values[5] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_self = values[0]; __pyx_v_filename = values[1]; __pyx_v_mode = values[2]; __pyx_v_estimated_records = values[3]; __pyx_v_delta_nodes_cache_size = values[4]; __pyx_v_delta_nodes_size = values[5]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 6, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB___init__(__pyx_self, __pyx_v_self, __pyx_v_filename, __pyx_v_mode, __pyx_v_estimated_records, __pyx_v_delta_nodes_cache_size, __pyx_v_delta_nodes_size); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_filename, PyObject *__pyx_v_mode, PyObject *__pyx_v_estimated_records, PyObject *__pyx_v_delta_nodes_cache_size, PyObject *__pyx_v_delta_nodes_size) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "imposm/cache/tc.pyx":393 * class DeltaCoordsDB(object): * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): * self.db = BDB(filename, mode, estimated_records) # <<<<<<<<<<<<<< * self.mode = mode * self.delta_nodes = {} */ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); __Pyx_INCREF(__pyx_v_mode); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_mode); __Pyx_GIVEREF(__pyx_v_mode); __Pyx_INCREF(__pyx_v_estimated_records); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_estimated_records); __Pyx_GIVEREF(__pyx_v_estimated_records); __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)((PyObject*)__pyx_ptype_6imposm_5cache_2tc_BDB)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_db, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":394 * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): * self.db = BDB(filename, mode, estimated_records) * self.mode = mode # <<<<<<<<<<<<<< * self.delta_nodes = {} * self.delta_node_ids = deque() */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mode, __pyx_v_mode) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 394; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":395 * self.db = BDB(filename, mode, estimated_records) * self.mode = mode * self.delta_nodes = {} # <<<<<<<<<<<<<< * self.delta_node_ids = deque() * self.delta_nodes_cache_size = delta_nodes_cache_size */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":396 * self.mode = mode * self.delta_nodes = {} * self.delta_node_ids = deque() # <<<<<<<<<<<<<< * self.delta_nodes_cache_size = delta_nodes_cache_size * self.delta_nodes_size = delta_nodes_size */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_deque); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (__pyx_t_3) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_node_ids, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":397 * self.delta_nodes = {} * self.delta_node_ids = deque() * self.delta_nodes_cache_size = delta_nodes_cache_size # <<<<<<<<<<<<<< * self.delta_nodes_size = delta_nodes_size * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes_cache_size, __pyx_v_delta_nodes_cache_size) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 397; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":398 * self.delta_node_ids = deque() * self.delta_nodes_cache_size = delta_nodes_cache_size * self.delta_nodes_size = delta_nodes_size # <<<<<<<<<<<<<< * * def put(self, int64_t osmid, double lon, double lat): */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes_size, __pyx_v_delta_nodes_size) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":392 * * class DeltaCoordsDB(object): * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): # <<<<<<<<<<<<<< * self.db = BDB(filename, mode, estimated_records) * self.mode = mode */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":400 * self.delta_nodes_size = delta_nodes_size * * def put(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * if self.mode == 'r': * return None */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_3put = {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_3put, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_3put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; int64_t __pyx_v_osmid; double __pyx_v_lon; double __pyx_v_lat; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_osmid,&__pyx_n_s_lon,&__pyx_n_s_lat,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lon)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_lat)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("put", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_self = values[0]; __pyx_v_osmid = __Pyx_PyInt_As_int64_t(values[1]); if (unlikely((__pyx_v_osmid == (int64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_lon = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_lon == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_lat = __pyx_PyFloat_AsDouble(values[3]); if (unlikely((__pyx_v_lat == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("put", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_2put(__pyx_self, __pyx_v_self, __pyx_v_osmid, __pyx_v_lon, __pyx_v_lat); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_2put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, int64_t __pyx_v_osmid, double __pyx_v_lon, double __pyx_v_lat) { PyObject *__pyx_v_delta_id = NULL; PyObject *__pyx_v_delta_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("put", 0); /* "imposm/cache/tc.pyx":401 * * def put(self, int64_t osmid, double lon, double lat): * if self.mode == 'r': # <<<<<<<<<<<<<< * return None * delta_id = osmid >> self.delta_nodes_size */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 401; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_r, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 401; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { /* "imposm/cache/tc.pyx":402 * def put(self, int64_t osmid, double lon, double lat): * if self.mode == 'r': * return None # <<<<<<<<<<<<<< * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; goto __pyx_L0; } /* "imposm/cache/tc.pyx":403 * if self.mode == 'r': * return None * delta_id = osmid >> self.delta_nodes_size # <<<<<<<<<<<<<< * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) */ __pyx_t_1 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 403; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 403; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyNumber_Rshift(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 403; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_delta_id = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":404 * return None * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: # <<<<<<<<<<<<<< * self.fetch_delta_node(delta_id) * delta_node = self.delta_nodes[delta_id] */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = (__Pyx_PySequence_Contains(__pyx_v_delta_id, __pyx_t_4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = (__pyx_t_2 != 0); if (__pyx_t_5) { /* "imposm/cache/tc.pyx":405 * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) # <<<<<<<<<<<<<< * delta_node = self.delta_nodes[delta_id] * delta_node.add(osmid, lon, lat) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_fetch_delta_node); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 405; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_1) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_delta_id); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 405; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 405; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; __Pyx_INCREF(__pyx_v_delta_id); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_delta_id); __Pyx_GIVEREF(__pyx_v_delta_id); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 405; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4; } __pyx_L4:; /* "imposm/cache/tc.pyx":406 * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) * delta_node = self.delta_nodes[delta_id] # <<<<<<<<<<<<<< * delta_node.add(osmid, lon, lat) * return True */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 406; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyObject_GetItem(__pyx_t_4, __pyx_v_delta_id); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 406; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_delta_node = __pyx_t_3; __pyx_t_3 = 0; /* "imposm/cache/tc.pyx":407 * self.fetch_delta_node(delta_id) * delta_node = self.delta_nodes[delta_id] * delta_node.add(osmid, lon, lat) # <<<<<<<<<<<<<< * return True * */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta_node, __pyx_n_s_add); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyInt_From_int64_t(__pyx_v_osmid); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = PyFloat_FromDouble(__pyx_v_lon); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = PyFloat_FromDouble(__pyx_v_lat); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_9 = 1; } } __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_6 = 0; __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 407; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "imposm/cache/tc.pyx":408 * delta_node = self.delta_nodes[delta_id] * delta_node.add(osmid, lon, lat) * return True # <<<<<<<<<<<<<< * * put_marshaled = put */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; /* "imposm/cache/tc.pyx":400 * self.delta_nodes_size = delta_nodes_size * * def put(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * if self.mode == 'r': * return None */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_delta_id); __Pyx_XDECREF(__pyx_v_delta_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":412 * put_marshaled = put * * def get(self, osmid): # <<<<<<<<<<<<<< * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_5get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_5get = {"get", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_5get, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_5get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_osmid = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_osmid,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmid)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("get", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_osmid = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_4get(__pyx_self, __pyx_v_self, __pyx_v_osmid); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_4get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_osmid) { PyObject *__pyx_v_delta_id = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get", 0); /* "imposm/cache/tc.pyx":413 * * def get(self, osmid): * delta_id = osmid >> self.delta_nodes_size # <<<<<<<<<<<<<< * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes_size); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Rshift(__pyx_v_osmid, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 413; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_delta_id = __pyx_t_2; __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":414 * def get(self, osmid): * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: # <<<<<<<<<<<<<< * self.fetch_delta_node(delta_id) * return self.delta_nodes[delta_id].get(osmid) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = (__Pyx_PySequence_Contains(__pyx_v_delta_id, __pyx_t_2, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = (__pyx_t_3 != 0); if (__pyx_t_4) { /* "imposm/cache/tc.pyx":415 * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) # <<<<<<<<<<<<<< * return self.delta_nodes[delta_id].get(osmid) * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_fetch_delta_node); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_5) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_delta_id); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_delta_id); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_delta_id); __Pyx_GIVEREF(__pyx_v_delta_id); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":416 * if delta_id not in self.delta_nodes: * self.fetch_delta_node(delta_id) * return self.delta_nodes[delta_id].get(osmid) # <<<<<<<<<<<<<< * * def get_coords(self, osmids): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = PyObject_GetItem(__pyx_t_1, __pyx_v_delta_id); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_6) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_osmid); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; __Pyx_INCREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_osmid); __Pyx_GIVEREF(__pyx_v_osmid); __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":412 * put_marshaled = put * * def get(self, osmid): # <<<<<<<<<<<<<< * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_delta_id); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":418 * return self.delta_nodes[delta_id].get(osmid) * * def get_coords(self, osmids): # <<<<<<<<<<<<<< * coords = [] * for osmid in osmids: */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_7get_coords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_7get_coords = {"get_coords", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_7get_coords, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_7get_coords(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_osmids = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_coords (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_osmids,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_osmids)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("get_coords", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_coords") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_osmids = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("get_coords", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.get_coords", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_6get_coords(__pyx_self, __pyx_v_self, __pyx_v_osmids); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_6get_coords(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_osmids) { PyObject *__pyx_v_coords = NULL; PyObject *__pyx_v_osmid = NULL; PyObject *__pyx_v_coord = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_coords", 0); /* "imposm/cache/tc.pyx":419 * * def get_coords(self, osmids): * coords = [] # <<<<<<<<<<<<<< * for osmid in osmids: * coord = self.get(osmid) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 419; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_coords = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":420 * def get_coords(self, osmids): * coords = [] * for osmid in osmids: # <<<<<<<<<<<<<< * coord = self.get(osmid) * if coord is None: */ if (likely(PyList_CheckExact(__pyx_v_osmids)) || PyTuple_CheckExact(__pyx_v_osmids)) { __pyx_t_1 = __pyx_v_osmids; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_osmids); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif } } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_osmid, __pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":421 * coords = [] * for osmid in osmids: * coord = self.get(osmid) # <<<<<<<<<<<<<< * if coord is None: * return */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_get); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_osmid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; __Pyx_INCREF(__pyx_v_osmid); PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_osmid); __Pyx_GIVEREF(__pyx_v_osmid); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 421; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_coord, __pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":422 * for osmid in osmids: * coord = self.get(osmid) * if coord is None: # <<<<<<<<<<<<<< * return * coords.append(coord) */ __pyx_t_8 = (__pyx_v_coord == Py_None); __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { /* "imposm/cache/tc.pyx":423 * coord = self.get(osmid) * if coord is None: * return # <<<<<<<<<<<<<< * coords.append(coord) * return coords */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L0; } /* "imposm/cache/tc.pyx":424 * if coord is None: * return * coords.append(coord) # <<<<<<<<<<<<<< * return coords * */ __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_coords, __pyx_v_coord); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 424; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":420 * def get_coords(self, osmids): * coords = [] * for osmid in osmids: # <<<<<<<<<<<<<< * coord = self.get(osmid) * if coord is None: */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":425 * return * coords.append(coord) * return coords # <<<<<<<<<<<<<< * * def close(self): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_coords); __pyx_r = __pyx_v_coords; goto __pyx_L0; /* "imposm/cache/tc.pyx":418 * return self.delta_nodes[delta_id].get(osmid) * * def get_coords(self, osmids): # <<<<<<<<<<<<<< * coords = [] * for osmid in osmids: */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.get_coords", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_coords); __Pyx_XDECREF(__pyx_v_osmid); __Pyx_XDECREF(__pyx_v_coord); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":427 * return coords * * def close(self): # <<<<<<<<<<<<<< * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_9close(PyObject *__pyx_self, PyObject *__pyx_v_self); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_9close = {"close", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_9close, METH_O, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_9close(PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_8close(__pyx_self, ((PyObject *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_8close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self) { PyObject *__pyx_v_node_id = NULL; PyObject *__pyx_v_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "imposm/cache/tc.pyx":428 * * def close(self): * for node_id, node in self.delta_nodes.iteritems(): # <<<<<<<<<<<<<< * self._put(node_id, node) * self.delta_nodes = {} */ __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 428; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (unlikely(__pyx_t_5 == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "iteritems"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 428; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_6 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_n_s_iteritems, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 428; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_6; __pyx_t_6 = 0; while (1) { __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_6, &__pyx_t_5, NULL, __pyx_t_4); if (unlikely(__pyx_t_7 == 0)) break; if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 428; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_node_id, __pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF_SET(__pyx_v_node, __pyx_t_5); __pyx_t_5 = 0; /* "imposm/cache/tc.pyx":429 * def close(self): * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) # <<<<<<<<<<<<<< * self.delta_nodes = {} * self.delta_node_ids = deque() */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_put); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_9 = 1; } } __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_v_node_id); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_v_node_id); __Pyx_GIVEREF(__pyx_v_node_id); __Pyx_INCREF(__pyx_v_node); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_node); __Pyx_GIVEREF(__pyx_v_node); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 429; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":430 * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) * self.delta_nodes = {} # <<<<<<<<<<<<<< * self.delta_node_ids = deque() * self.db.close() */ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 430; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 430; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":431 * self._put(node_id, node) * self.delta_nodes = {} * self.delta_node_ids = deque() # <<<<<<<<<<<<<< * self.db.close() * */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_deque); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_delta_node_ids, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 431; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":432 * self.delta_nodes = {} * self.delta_node_ids = deque() * self.db.close() # <<<<<<<<<<<<<< * * def _put(self, delta_id, delta_node): */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_db); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 432; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_close); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 432; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_5) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 432; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 432; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":427 * return coords * * def close(self): # <<<<<<<<<<<<<< * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_node_id); __Pyx_XDECREF(__pyx_v_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":434 * self.db.close() * * def _put(self, delta_id, delta_node): # <<<<<<<<<<<<<< * data = delta_node.serialize() * self.db.put_marshaled(delta_id, data) */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_11_put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_11_put = {"_put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_11_put, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_11_put(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_delta_id = 0; PyObject *__pyx_v_delta_node = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_put (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_delta_id,&__pyx_n_s_delta_node,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_id)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_put", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_node)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_put", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_self = values[0]; __pyx_v_delta_id = values[1]; __pyx_v_delta_node = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_put", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB._put", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_10_put(__pyx_self, __pyx_v_self, __pyx_v_delta_id, __pyx_v_delta_node); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_10_put(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id, PyObject *__pyx_v_delta_node) { PyObject *__pyx_v_data = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; Py_ssize_t __pyx_t_4; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_put", 0); /* "imposm/cache/tc.pyx":435 * * def _put(self, delta_id, delta_node): * data = delta_node.serialize() # <<<<<<<<<<<<<< * self.db.put_marshaled(delta_id, data) * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_delta_node, __pyx_n_s_serialize); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 435; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_data = __pyx_t_1; __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":436 * def _put(self, delta_id, delta_node): * data = delta_node.serialize() * self.db.put_marshaled(delta_id, data) # <<<<<<<<<<<<<< * * def _get(self, delta_id): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_db); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put_marshaled); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; __pyx_t_4 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_4 = 1; } } __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_2) { PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = NULL; } __Pyx_INCREF(__pyx_v_delta_id); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_4, __pyx_v_delta_id); __Pyx_GIVEREF(__pyx_v_delta_id); __Pyx_INCREF(__pyx_v_data); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_data); __Pyx_GIVEREF(__pyx_v_data); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":434 * self.db.close() * * def _put(self, delta_id, delta_node): # <<<<<<<<<<<<<< * data = delta_node.serialize() * self.db.put_marshaled(delta_id, data) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB._put", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_data); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":438 * self.db.put_marshaled(delta_id, data) * * def _get(self, delta_id): # <<<<<<<<<<<<<< * return DeltaNodes(data=self.db.get_raw(delta_id)) * */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_13_get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_13_get = {"_get", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_13_get, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_13_get(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_delta_id = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_get (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_delta_id,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_id)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_get", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_delta_id = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_get", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB._get", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_12_get(__pyx_self, __pyx_v_self, __pyx_v_delta_id); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_12_get(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_get", 0); /* "imposm/cache/tc.pyx":439 * * def _get(self, delta_id): * return DeltaNodes(data=self.db.get_raw(delta_id)) # <<<<<<<<<<<<<< * * def fetch_delta_node(self, delta_id): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_DeltaNodes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_db); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get_raw); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_4) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_delta_id); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_delta_id); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_delta_id); __Pyx_GIVEREF(__pyx_v_delta_id); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_data, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "imposm/cache/tc.pyx":438 * self.db.put_marshaled(delta_id, data) * * def _get(self, delta_id): # <<<<<<<<<<<<<< * return DeltaNodes(data=self.db.get_raw(delta_id)) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB._get", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "imposm/cache/tc.pyx":441 * return DeltaNodes(data=self.db.get_raw(delta_id)) * * def fetch_delta_node(self, delta_id): # <<<<<<<<<<<<<< * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() */ /* Python wrapper */ static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_15fetch_delta_node(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static PyMethodDef __pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_15fetch_delta_node = {"fetch_delta_node", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_15fetch_delta_node, METH_VARARGS|METH_KEYWORDS, 0}; static PyObject *__pyx_pw_6imposm_5cache_2tc_13DeltaCoordsDB_15fetch_delta_node(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_self = 0; PyObject *__pyx_v_delta_id = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fetch_delta_node (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_delta_id,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delta_id)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fetch_delta_node", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fetch_delta_node") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_self = values[0]; __pyx_v_delta_id = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fetch_delta_node", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.fetch_delta_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_14fetch_delta_node(__pyx_self, __pyx_v_self, __pyx_v_delta_id); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6imposm_5cache_2tc_13DeltaCoordsDB_14fetch_delta_node(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_delta_id) { PyObject *__pyx_v_rm_id = NULL; PyObject *__pyx_v_rm_node = NULL; PyObject *__pyx_v_new_node = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fetch_delta_node", 0); /* "imposm/cache/tc.pyx":442 * * def fetch_delta_node(self, delta_id): * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: # <<<<<<<<<<<<<< * rm_id = self.delta_node_ids.popleft() * rm_node = self.delta_nodes.pop(rm_id) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_node_ids); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes_cache_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 442; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_5) { /* "imposm/cache/tc.pyx":443 * def fetch_delta_node(self, delta_id): * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() # <<<<<<<<<<<<<< * rm_node = self.delta_nodes.pop(rm_id) * if rm_node.changed: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_node_ids); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_popleft); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (__pyx_t_3) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_rm_id = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":444 * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() * rm_node = self.delta_nodes.pop(rm_id) # <<<<<<<<<<<<<< * if rm_node.changed: * self._put(rm_id, rm_node) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_pop); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_1) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_rm_id); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; __Pyx_INCREF(__pyx_v_rm_id); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_rm_id); __Pyx_GIVEREF(__pyx_v_rm_id); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_rm_node = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":445 * rm_id = self.delta_node_ids.popleft() * rm_node = self.delta_nodes.pop(rm_id) * if rm_node.changed: # <<<<<<<<<<<<<< * self._put(rm_id, rm_node) * new_node = self._get(delta_id) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rm_node, __pyx_n_s_changed); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 445; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 445; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_5) { /* "imposm/cache/tc.pyx":446 * rm_node = self.delta_nodes.pop(rm_id) * if rm_node.changed: * self._put(rm_id, rm_node) # <<<<<<<<<<<<<< * new_node = self._get(delta_id) * if new_node is None: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; __pyx_t_2 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_2 = 1; } } __pyx_t_1 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_v_rm_id); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_2, __pyx_v_rm_id); __Pyx_GIVEREF(__pyx_v_rm_id); __Pyx_INCREF(__pyx_v_rm_node); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_2, __pyx_v_rm_node); __Pyx_GIVEREF(__pyx_v_rm_node); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4; } __pyx_L4:; goto __pyx_L3; } __pyx_L3:; /* "imposm/cache/tc.pyx":447 * if rm_node.changed: * self._put(rm_id, rm_node) * new_node = self._get(delta_id) # <<<<<<<<<<<<<< * if new_node is None: * new_node = DeltaNodes() */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_get_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_1) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_delta_id); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; __Pyx_INCREF(__pyx_v_delta_id); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_delta_id); __Pyx_GIVEREF(__pyx_v_delta_id); __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 447; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_new_node = __pyx_t_4; __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":448 * self._put(rm_id, rm_node) * new_node = self._get(delta_id) * if new_node is None: # <<<<<<<<<<<<<< * new_node = DeltaNodes() * self.delta_nodes[delta_id] = new_node */ __pyx_t_5 = (__pyx_v_new_node == Py_None); __pyx_t_7 = (__pyx_t_5 != 0); if (__pyx_t_7) { /* "imposm/cache/tc.pyx":449 * new_node = self._get(delta_id) * if new_node is None: * new_node = DeltaNodes() # <<<<<<<<<<<<<< * self.delta_nodes[delta_id] = new_node * self.delta_node_ids.append(delta_id) */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DeltaNodes); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_new_node, __pyx_t_4); __pyx_t_4 = 0; goto __pyx_L5; } __pyx_L5:; /* "imposm/cache/tc.pyx":450 * if new_node is None: * new_node = DeltaNodes() * self.delta_nodes[delta_id] = new_node # <<<<<<<<<<<<<< * self.delta_node_ids.append(delta_id) * */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_nodes); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_delta_id, __pyx_v_new_node) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":451 * new_node = DeltaNodes() * self.delta_nodes[delta_id] = new_node * self.delta_node_ids.append(delta_id) # <<<<<<<<<<<<<< * */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_delta_node_ids); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_v_delta_id); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":441 * return DeltaNodes(data=self.db.get_raw(delta_id)) * * def fetch_delta_node(self, delta_id): # <<<<<<<<<<<<<< * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("imposm.cache.tc.DeltaCoordsDB.fetch_delta_node", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_rm_id); __Pyx_XDECREF(__pyx_v_rm_node); __Pyx_XDECREF(__pyx_v_new_node); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB __pyx_vtable_6imposm_5cache_2tc_BDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_BDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_BDB *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_BDB *)o); p->__pyx_vtab = __pyx_vtabptr_6imposm_5cache_2tc_BDB; p->filename = Py_None; Py_INCREF(Py_None); if (unlikely(__pyx_pw_6imposm_5cache_2tc_3BDB_1__cinit__(o, a, k) < 0)) { Py_DECREF(o); o = 0; } return o; } static void __pyx_tp_dealloc_6imposm_5cache_2tc_BDB(PyObject *o) { struct __pyx_obj_6imposm_5cache_2tc_BDB *p = (struct __pyx_obj_6imposm_5cache_2tc_BDB *)o; #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); ++Py_REFCNT(o); __pyx_pw_6imposm_5cache_2tc_3BDB_25__dealloc__(o); --Py_REFCNT(o); PyErr_Restore(etype, eval, etb); } Py_CLEAR(p->filename); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_6imposm_5cache_2tc_BDB(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_6imposm_5cache_2tc_BDB *p = (struct __pyx_obj_6imposm_5cache_2tc_BDB *)o; if (p->filename) { e = (*v)(p->filename, a); if (e) return e; } return 0; } static int __pyx_tp_clear_6imposm_5cache_2tc_BDB(PyObject *o) { PyObject* tmp; struct __pyx_obj_6imposm_5cache_2tc_BDB *p = (struct __pyx_obj_6imposm_5cache_2tc_BDB *)o; tmp = ((PyObject*)p->filename); p->filename = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_6imposm_5cache_2tc_BDB[] = { {"_tune_db", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_5_tune_db, METH_O, 0}, {"get", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_7get, METH_O, __pyx_doc_6imposm_5cache_2tc_3BDB_6get}, {"get_raw", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_9get_raw, METH_O, __pyx_doc_6imposm_5cache_2tc_3BDB_8get_raw}, {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_11put, METH_VARARGS|METH_KEYWORDS, 0}, {"put_marshaled", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_13put_marshaled, METH_VARARGS|METH_KEYWORDS, 0}, {"__next__", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, METH_NOARGS|METH_COEXIST, __pyx_doc_6imposm_5cache_2tc_3BDB_20__next__}, {"close", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_3BDB_23close, METH_NOARGS, 0}, {0, 0, 0, 0} }; static PySequenceMethods __pyx_tp_as_sequence_BDB = { __pyx_pw_6imposm_5cache_2tc_3BDB_19__len__, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ 0, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ __pyx_pw_6imposm_5cache_2tc_3BDB_17__contains__, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_BDB = { __pyx_pw_6imposm_5cache_2tc_3BDB_19__len__, /*mp_length*/ 0, /*mp_subscript*/ 0, /*mp_ass_subscript*/ }; static PyTypeObject __pyx_type_6imposm_5cache_2tc_BDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.BDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_BDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ &__pyx_tp_as_sequence_BDB, /*tp_as_sequence*/ &__pyx_tp_as_mapping_BDB, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ __pyx_methods_6imposm_5cache_2tc_BDB, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_BDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_CoordDB __pyx_vtable_6imposm_5cache_2tc_CoordDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_CoordDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_CoordDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_BDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_CoordDB *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_CoordDB; return o; } static PyMethodDef __pyx_methods_6imposm_5cache_2tc_CoordDB[] = { {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_7CoordDB_1put, METH_VARARGS|METH_KEYWORDS, 0}, {"put_marshaled", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_7CoordDB_3put_marshaled, METH_VARARGS|METH_KEYWORDS, 0}, {"get", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_7CoordDB_5get, METH_O, 0}, {"get_coords", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_7CoordDB_7get_coords, METH_O, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6imposm_5cache_2tc_CoordDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.CoordDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_CoordDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ #else 0, /*tp_iternext*/ #endif __pyx_methods_6imposm_5cache_2tc_CoordDB, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_CoordDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_NodeDB __pyx_vtable_6imposm_5cache_2tc_NodeDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_NodeDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_NodeDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_BDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_NodeDB *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_NodeDB; return o; } static PyMethodDef __pyx_methods_6imposm_5cache_2tc_NodeDB[] = { {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_6NodeDB_1put, METH_VARARGS|METH_KEYWORDS, 0}, {"put_marshaled", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_6NodeDB_3put_marshaled, METH_VARARGS|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6imposm_5cache_2tc_NodeDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.NodeDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_NodeDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ #else 0, /*tp_iternext*/ #endif __pyx_methods_6imposm_5cache_2tc_NodeDB, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_NodeDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_InsertedWayDB __pyx_vtable_6imposm_5cache_2tc_InsertedWayDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_InsertedWayDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_BDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_InsertedWayDB; return o; } static PyMethodDef __pyx_methods_6imposm_5cache_2tc_InsertedWayDB[] = { {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_1put, METH_O, 0}, {"__next__", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_3__next__, METH_NOARGS|METH_COEXIST, __pyx_doc_6imposm_5cache_2tc_13InsertedWayDB_2__next__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6imposm_5cache_2tc_InsertedWayDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.InsertedWayDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_InsertedWayDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif __pyx_pw_6imposm_5cache_2tc_13InsertedWayDB_3__next__, /*tp_iternext*/ __pyx_methods_6imposm_5cache_2tc_InsertedWayDB, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_InsertedWayDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_RefTagDB __pyx_vtable_6imposm_5cache_2tc_RefTagDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_RefTagDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_BDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_RefTagDB *)o); p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_RefTagDB; return o; } static PyMethodDef __pyx_methods_6imposm_5cache_2tc_RefTagDB[] = { {"put", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_8RefTagDB_1put, METH_VARARGS|METH_KEYWORDS, 0}, {"put_marshaled", (PyCFunction)__pyx_pw_6imposm_5cache_2tc_8RefTagDB_3put_marshaled, METH_VARARGS|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6imposm_5cache_2tc_RefTagDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.RefTagDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_RefTagDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n Database for items with references and tags (i.e. ways/relations).\n ", /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ #else 0, /*tp_iternext*/ #endif __pyx_methods_6imposm_5cache_2tc_RefTagDB, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_RefTagDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_WayDB __pyx_vtable_6imposm_5cache_2tc_WayDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_WayDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_WayDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_RefTagDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_WayDB *)o); p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_WayDB; return o; } static PyTypeObject __pyx_type_6imposm_5cache_2tc_WayDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.WayDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_WayDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ #else 0, /*tp_iternext*/ #endif 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_WayDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static struct __pyx_vtabstruct_6imposm_5cache_2tc_RelationDB __pyx_vtable_6imposm_5cache_2tc_RelationDB; static PyObject *__pyx_tp_new_6imposm_5cache_2tc_RelationDB(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_6imposm_5cache_2tc_RelationDB *p; PyObject *o = __pyx_tp_new_6imposm_5cache_2tc_RefTagDB(t, a, k); if (unlikely(!o)) return 0; p = ((struct __pyx_obj_6imposm_5cache_2tc_RelationDB *)o); p->__pyx_base.__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_6imposm_5cache_2tc_BDB*)__pyx_vtabptr_6imposm_5cache_2tc_RelationDB; return o; } static PyTypeObject __pyx_type_6imposm_5cache_2tc_RelationDB = { PyVarObject_HEAD_INIT(0, 0) "imposm.cache.tc.RelationDB", /*tp_name*/ sizeof(struct __pyx_obj_6imposm_5cache_2tc_RelationDB), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6imposm_5cache_2tc_BDB, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_6imposm_5cache_2tc_BDB, /*tp_traverse*/ __pyx_tp_clear_6imposm_5cache_2tc_BDB, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_15__iter__, /*tp_iter*/ #else 0, /*tp_iter*/ #endif #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_21__next__, /*tp_iternext*/ #else 0, /*tp_iternext*/ #endif 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ #if CYTHON_COMPILING_IN_PYPY __pyx_pw_6imposm_5cache_2tc_3BDB_3__init__, /*tp_init*/ #else 0, /*tp_init*/ #endif 0, /*tp_alloc*/ __pyx_tp_new_6imposm_5cache_2tc_RelationDB, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "tc", 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_DeltaCoords, __pyx_k_DeltaCoords, sizeof(__pyx_k_DeltaCoords), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB, __pyx_k_DeltaCoordsDB, sizeof(__pyx_k_DeltaCoordsDB), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB___init, __pyx_k_DeltaCoordsDB___init, sizeof(__pyx_k_DeltaCoordsDB___init), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB__get, __pyx_k_DeltaCoordsDB__get, sizeof(__pyx_k_DeltaCoordsDB__get), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB__put, __pyx_k_DeltaCoordsDB__put, sizeof(__pyx_k_DeltaCoordsDB__put), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB_close, __pyx_k_DeltaCoordsDB_close, sizeof(__pyx_k_DeltaCoordsDB_close), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB_fetch_delta_node, __pyx_k_DeltaCoordsDB_fetch_delta_node, sizeof(__pyx_k_DeltaCoordsDB_fetch_delta_node), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB_get, __pyx_k_DeltaCoordsDB_get, sizeof(__pyx_k_DeltaCoordsDB_get), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB_get_coords, __pyx_k_DeltaCoordsDB_get_coords, sizeof(__pyx_k_DeltaCoordsDB_get_coords), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoordsDB_put, __pyx_k_DeltaCoordsDB_put, sizeof(__pyx_k_DeltaCoordsDB_put), 0, 0, 1, 1}, {&__pyx_n_s_DeltaCoords_2, __pyx_k_DeltaCoords_2, sizeof(__pyx_k_DeltaCoords_2), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes, __pyx_k_DeltaNodes, sizeof(__pyx_k_DeltaNodes), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes___init, __pyx_k_DeltaNodes___init, sizeof(__pyx_k_DeltaNodes___init), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes_add, __pyx_k_DeltaNodes_add, sizeof(__pyx_k_DeltaNodes_add), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes_changed, __pyx_k_DeltaNodes_changed, sizeof(__pyx_k_DeltaNodes_changed), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes_deserialize, __pyx_k_DeltaNodes_deserialize, sizeof(__pyx_k_DeltaNodes_deserialize), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes_get, __pyx_k_DeltaNodes_get, sizeof(__pyx_k_DeltaNodes_get), 0, 0, 1, 1}, {&__pyx_n_s_DeltaNodes_serialize, __pyx_k_DeltaNodes_serialize, sizeof(__pyx_k_DeltaNodes_serialize), 0, 0, 1, 1}, {&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1}, {&__pyx_n_s_Node, __pyx_k_Node, sizeof(__pyx_k_Node), 0, 0, 1, 1}, {&__pyx_n_s_ParseFromString, __pyx_k_ParseFromString, sizeof(__pyx_k_ParseFromString), 0, 0, 1, 1}, {&__pyx_n_s_Relation, __pyx_k_Relation, sizeof(__pyx_k_Relation), 0, 0, 1, 1}, {&__pyx_n_s_SerializeToString, __pyx_k_SerializeToString, sizeof(__pyx_k_SerializeToString), 0, 0, 1, 1}, {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, {&__pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_k_Users_olt_dev_imposm_git_imposm, sizeof(__pyx_k_Users_olt_dev_imposm_git_imposm), 0, 0, 1, 0}, {&__pyx_n_s_Way, __pyx_k_Way, sizeof(__pyx_k_Way), 0, 0, 1, 1}, {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, {&__pyx_n_s_bisect, __pyx_k_bisect, sizeof(__pyx_k_bisect), 0, 0, 1, 1}, {&__pyx_n_s_changed, __pyx_k_changed, sizeof(__pyx_k_changed), 0, 0, 1, 1}, {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, {&__pyx_n_s_coord, __pyx_k_coord, sizeof(__pyx_k_coord), 0, 0, 1, 1}, {&__pyx_n_s_coords, __pyx_k_coords, sizeof(__pyx_k_coords), 0, 0, 1, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_db, __pyx_k_db, sizeof(__pyx_k_db), 0, 0, 1, 1}, {&__pyx_n_s_delta_id, __pyx_k_delta_id, sizeof(__pyx_k_delta_id), 0, 0, 1, 1}, {&__pyx_n_s_delta_node, __pyx_k_delta_node, sizeof(__pyx_k_delta_node), 0, 0, 1, 1}, {&__pyx_n_s_delta_node_ids, __pyx_k_delta_node_ids, sizeof(__pyx_k_delta_node_ids), 0, 0, 1, 1}, {&__pyx_n_s_delta_nodes, __pyx_k_delta_nodes, sizeof(__pyx_k_delta_nodes), 0, 0, 1, 1}, {&__pyx_n_s_delta_nodes_cache_size, __pyx_k_delta_nodes_cache_size, sizeof(__pyx_k_delta_nodes_cache_size), 0, 0, 1, 1}, {&__pyx_n_s_delta_nodes_size, __pyx_k_delta_nodes_size, sizeof(__pyx_k_delta_nodes_size), 0, 0, 1, 1}, {&__pyx_n_s_deque, __pyx_k_deque, sizeof(__pyx_k_deque), 0, 0, 1, 1}, {&__pyx_n_s_deserialize, __pyx_k_deserialize, sizeof(__pyx_k_deserialize), 0, 0, 1, 1}, {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, {&__pyx_n_s_estimated_records, __pyx_k_estimated_records, sizeof(__pyx_k_estimated_records), 0, 0, 1, 1}, {&__pyx_n_s_fetch_delta_node, __pyx_k_fetch_delta_node, sizeof(__pyx_k_fetch_delta_node), 0, 0, 1, 1}, {&__pyx_n_s_filename, __pyx_k_filename, sizeof(__pyx_k_filename), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_get_2, __pyx_k_get_2, sizeof(__pyx_k_get_2), 0, 0, 1, 1}, {&__pyx_n_s_get_coords, __pyx_k_get_coords, sizeof(__pyx_k_get_coords), 0, 0, 1, 1}, {&__pyx_n_s_get_raw, __pyx_k_get_raw, sizeof(__pyx_k_get_raw), 0, 0, 1, 1}, {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, {&__pyx_n_s_ids, __pyx_k_ids, sizeof(__pyx_k_ids), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_imposm_base, __pyx_k_imposm_base, sizeof(__pyx_k_imposm_base), 0, 0, 1, 1}, {&__pyx_n_s_imposm_cache_internal, __pyx_k_imposm_cache_internal, sizeof(__pyx_k_imposm_cache_internal), 0, 0, 1, 1}, {&__pyx_n_s_imposm_cache_tc, __pyx_k_imposm_cache_tc, sizeof(__pyx_k_imposm_cache_tc), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_s_insort, __pyx_k_insort, sizeof(__pyx_k_insort), 0, 0, 1, 1}, {&__pyx_n_s_iteritems, __pyx_k_iteritems, sizeof(__pyx_k_iteritems), 0, 0, 1, 1}, {&__pyx_n_s_lat, __pyx_k_lat, sizeof(__pyx_k_lat), 0, 0, 1, 1}, {&__pyx_n_s_lats, __pyx_k_lats, sizeof(__pyx_k_lats), 0, 0, 1, 1}, {&__pyx_n_s_lon, __pyx_k_lon, sizeof(__pyx_k_lon), 0, 0, 1, 1}, {&__pyx_n_s_lons, __pyx_k_lons, sizeof(__pyx_k_lons), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, {&__pyx_n_s_modes, __pyx_k_modes, sizeof(__pyx_k_modes), 0, 0, 1, 1}, {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, {&__pyx_n_s_new_node, __pyx_k_new_node, sizeof(__pyx_k_new_node), 0, 0, 1, 1}, {&__pyx_n_s_node, __pyx_k_node, sizeof(__pyx_k_node), 0, 0, 1, 1}, {&__pyx_n_s_node_id, __pyx_k_node_id, sizeof(__pyx_k_node_id), 0, 0, 1, 1}, {&__pyx_n_s_nodes, __pyx_k_nodes, sizeof(__pyx_k_nodes), 0, 0, 1, 1}, {&__pyx_n_s_object, __pyx_k_object, sizeof(__pyx_k_object), 0, 0, 1, 1}, {&__pyx_n_s_osmid, __pyx_k_osmid, sizeof(__pyx_k_osmid), 0, 0, 1, 1}, {&__pyx_n_s_osmids, __pyx_k_osmids, sizeof(__pyx_k_osmids), 0, 0, 1, 1}, {&__pyx_n_s_pop, __pyx_k_pop, sizeof(__pyx_k_pop), 0, 0, 1, 1}, {&__pyx_n_s_popleft, __pyx_k_popleft, sizeof(__pyx_k_popleft), 0, 0, 1, 1}, {&__pyx_n_s_pos, __pyx_k_pos, sizeof(__pyx_k_pos), 0, 0, 1, 1}, {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, {&__pyx_n_s_put_2, __pyx_k_put_2, sizeof(__pyx_k_put_2), 0, 0, 1, 1}, {&__pyx_n_s_put_marshaled, __pyx_k_put_marshaled, sizeof(__pyx_k_put_marshaled), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_refs, __pyx_k_refs, sizeof(__pyx_k_refs), 0, 0, 1, 1}, {&__pyx_n_s_rm_id, __pyx_k_rm_id, sizeof(__pyx_k_rm_id), 0, 0, 1, 1}, {&__pyx_n_s_rm_node, __pyx_k_rm_node, sizeof(__pyx_k_rm_node), 0, 0, 1, 1}, {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, {&__pyx_n_s_serialize, __pyx_k_serialize, sizeof(__pyx_k_serialize), 0, 0, 1, 1}, {&__pyx_n_s_tags, __pyx_k_tags, sizeof(__pyx_k_tags), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_tune_db, __pyx_k_tune_db, sizeof(__pyx_k_tune_db), 0, 0, 1, 1}, {&__pyx_n_s_w, __pyx_k_w, sizeof(__pyx_k_w), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 182; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "imposm/cache/tc.pyx":366 * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: * return self.nodes[i][1:] # <<<<<<<<<<<<<< * return None * */ __pyx_slice_ = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_slice_); __Pyx_GIVEREF(__pyx_slice_); /* "imposm/cache/tc.pyx":354 * * class DeltaNodes(object): * def __init__(self, data=None): # <<<<<<<<<<<<<< * self.nodes = [] * self.changed = False */ __pyx_tuple__2 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_data); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); __pyx_codeobj__3 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_init, 354, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_tuple__4 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "imposm/cache/tc.pyx":360 * self.deserialize(data) * * def changed(self): # <<<<<<<<<<<<<< * return self.changed * */ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 360; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_changed, 360, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 360; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":363 * return self.changed * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: */ __pyx_tuple__7 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_osmid, __pyx_n_s_i); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__7, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_get, 363, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":369 * return None * * def add(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * # todo: overwrite * self.changed = True */ __pyx_tuple__9 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_osmid, __pyx_n_s_lon, __pyx_n_s_lat); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_add, 369, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":377 * bisect.insort(self.nodes, (osmid, lon, lat)) * * def serialize(self): # <<<<<<<<<<<<<< * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() */ __pyx_tuple__11 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_ids, __pyx_n_s_lons, __pyx_n_s_lats, __pyx_n_s_nodes); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 377; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_serialize, 377, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 377; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":385 * return nodes.SerializeToString() * * def deserialize(self, data): # <<<<<<<<<<<<<< * nodes = _DeltaCoords() * nodes.ParseFromString(data) */ __pyx_tuple__13 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_data, __pyx_n_s_nodes); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_deserialize, 385, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":392 * * class DeltaCoordsDB(object): * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): # <<<<<<<<<<<<<< * self.db = BDB(filename, mode, estimated_records) * self.mode = mode */ __pyx_tuple__15 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_filename, __pyx_n_s_mode, __pyx_n_s_estimated_records, __pyx_n_s_delta_nodes_cache_size, __pyx_n_s_delta_nodes_size); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(6, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__15, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_init, 392, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_tuple__17 = PyTuple_Pack(4, ((PyObject*)__pyx_n_s_w), ((PyObject *)__pyx_int_0), ((PyObject *)__pyx_int_100), ((PyObject *)__pyx_int_6)); if (unlikely(!__pyx_tuple__17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "imposm/cache/tc.pyx":400 * self.delta_nodes_size = delta_nodes_size * * def put(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * if self.mode == 'r': * return None */ __pyx_tuple__18 = PyTuple_Pack(6, __pyx_n_s_self, __pyx_n_s_osmid, __pyx_n_s_lon, __pyx_n_s_lat, __pyx_n_s_delta_id, __pyx_n_s_delta_node); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(4, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__18, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_put_2, 400, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":412 * put_marshaled = put * * def get(self, osmid): # <<<<<<<<<<<<<< * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: */ __pyx_tuple__20 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_osmid, __pyx_n_s_delta_id); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_get, 412, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":418 * return self.delta_nodes[delta_id].get(osmid) * * def get_coords(self, osmids): # <<<<<<<<<<<<<< * coords = [] * for osmid in osmids: */ __pyx_tuple__22 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_osmids, __pyx_n_s_coords, __pyx_n_s_osmid, __pyx_n_s_coord); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_get_coords, 418, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":427 * return coords * * def close(self): # <<<<<<<<<<<<<< * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) */ __pyx_tuple__24 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_node_id, __pyx_n_s_node); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); __pyx_codeobj__25 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__24, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_close, 427, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":434 * self.db.close() * * def _put(self, delta_id, delta_node): # <<<<<<<<<<<<<< * data = delta_node.serialize() * self.db.put_marshaled(delta_id, data) */ __pyx_tuple__26 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_delta_id, __pyx_n_s_delta_node, __pyx_n_s_data); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_put, 434, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":438 * self.db.put_marshaled(delta_id, data) * * def _get(self, delta_id): # <<<<<<<<<<<<<< * return DeltaNodes(data=self.db.get_raw(delta_id)) * */ __pyx_tuple__28 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_delta_id); if (unlikely(!__pyx_tuple__28)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__28); __Pyx_GIVEREF(__pyx_tuple__28); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_get_2, 438, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "imposm/cache/tc.pyx":441 * return DeltaNodes(data=self.db.get_raw(delta_id)) * * def fetch_delta_node(self, delta_id): # <<<<<<<<<<<<<< * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() */ __pyx_tuple__30 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_delta_id, __pyx_n_s_rm_id, __pyx_n_s_rm_node, __pyx_n_s_new_node); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_olt_dev_imposm_git_imposm, __pyx_n_s_fetch_delta_node, 441, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_100 = PyInt_FromLong(100); if (unlikely(!__pyx_int_100)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_128 = PyInt_FromLong(128); if (unlikely(!__pyx_int_128)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC inittc(void); /*proto*/ PyMODINIT_FUNC inittc(void) #else PyMODINIT_FUNC PyInit_tc(void); /*proto*/ PyMODINIT_FUNC PyInit_tc(void) #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_tc(void)", 0); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("tc", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_imposm__cache__tc) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "imposm.cache.tc")) { if (unlikely(PyDict_SetItemString(modules, "imposm.cache.tc", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ __pyx_vtabptr_6imposm_5cache_2tc_BDB = &__pyx_vtable_6imposm_5cache_2tc_BDB; __pyx_vtable_6imposm_5cache_2tc_BDB._obj = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *))__pyx_f_6imposm_5cache_2tc_3BDB__obj; __pyx_vtable_6imposm_5cache_2tc_BDB._get_cur = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *))__pyx_f_6imposm_5cache_2tc_3BDB__get_cur; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_BDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 90; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_BDB.tp_print = 0; #if CYTHON_COMPILING_IN_CPYTHON { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_6imposm_5cache_2tc_BDB, "__iter__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 90; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_14__iter__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_14__iter__.doc = __pyx_doc_6imposm_5cache_2tc_3BDB_14__iter__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_6imposm_5cache_2tc_3BDB_14__iter__; } } #endif #if CYTHON_COMPILING_IN_CPYTHON { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_6imposm_5cache_2tc_BDB, "__next__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 90; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_20__next__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_6imposm_5cache_2tc_3BDB_20__next__.doc = __pyx_doc_6imposm_5cache_2tc_3BDB_20__next__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_6imposm_5cache_2tc_3BDB_20__next__; } } #endif if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_BDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_BDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 90; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "BDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_BDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 90; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_BDB = &__pyx_type_6imposm_5cache_2tc_BDB; __pyx_vtabptr_6imposm_5cache_2tc_CoordDB = &__pyx_vtable_6imposm_5cache_2tc_CoordDB; __pyx_vtable_6imposm_5cache_2tc_CoordDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_BDB; __pyx_vtable_6imposm_5cache_2tc_CoordDB.__pyx_base._obj = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *))__pyx_f_6imposm_5cache_2tc_7CoordDB__obj; __pyx_vtable_6imposm_5cache_2tc_CoordDB.__pyx_base._get_cur = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *))__pyx_f_6imposm_5cache_2tc_7CoordDB__get_cur; __pyx_vtable_6imposm_5cache_2tc_CoordDB._put = (int (*)(struct __pyx_obj_6imposm_5cache_2tc_CoordDB *, int64_t, double, double))__pyx_f_6imposm_5cache_2tc_7CoordDB__put; __pyx_type_6imposm_5cache_2tc_CoordDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_BDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_CoordDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_CoordDB.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_CoordDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_CoordDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "CoordDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_CoordDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_CoordDB = &__pyx_type_6imposm_5cache_2tc_CoordDB; __pyx_vtabptr_6imposm_5cache_2tc_NodeDB = &__pyx_vtable_6imposm_5cache_2tc_NodeDB; __pyx_vtable_6imposm_5cache_2tc_NodeDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_BDB; __pyx_vtable_6imposm_5cache_2tc_NodeDB.__pyx_base._obj = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *))__pyx_f_6imposm_5cache_2tc_6NodeDB__obj; __pyx_type_6imposm_5cache_2tc_NodeDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_BDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_NodeDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_NodeDB.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_NodeDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_NodeDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "NodeDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_NodeDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_NodeDB = &__pyx_type_6imposm_5cache_2tc_NodeDB; __pyx_vtabptr_6imposm_5cache_2tc_InsertedWayDB = &__pyx_vtable_6imposm_5cache_2tc_InsertedWayDB; __pyx_vtable_6imposm_5cache_2tc_InsertedWayDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_BDB; __pyx_type_6imposm_5cache_2tc_InsertedWayDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_BDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_InsertedWayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_InsertedWayDB.tp_print = 0; #if CYTHON_COMPILING_IN_CPYTHON { PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_6imposm_5cache_2tc_InsertedWayDB, "__next__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_6imposm_5cache_2tc_13InsertedWayDB_2__next__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_6imposm_5cache_2tc_13InsertedWayDB_2__next__.doc = __pyx_doc_6imposm_5cache_2tc_13InsertedWayDB_2__next__; ((PyWrapperDescrObject *)wrapper)->d_base = &__pyx_wrapperbase_6imposm_5cache_2tc_13InsertedWayDB_2__next__; } } #endif if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_InsertedWayDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_InsertedWayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "InsertedWayDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_InsertedWayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_InsertedWayDB = &__pyx_type_6imposm_5cache_2tc_InsertedWayDB; __pyx_vtabptr_6imposm_5cache_2tc_RefTagDB = &__pyx_vtable_6imposm_5cache_2tc_RefTagDB; __pyx_vtable_6imposm_5cache_2tc_RefTagDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_BDB; __pyx_type_6imposm_5cache_2tc_RefTagDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_BDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_RefTagDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_RefTagDB.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_RefTagDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_RefTagDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "RefTagDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_RefTagDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_RefTagDB = &__pyx_type_6imposm_5cache_2tc_RefTagDB; __pyx_vtabptr_6imposm_5cache_2tc_WayDB = &__pyx_vtable_6imposm_5cache_2tc_WayDB; __pyx_vtable_6imposm_5cache_2tc_WayDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_RefTagDB; __pyx_vtable_6imposm_5cache_2tc_WayDB.__pyx_base.__pyx_base._obj = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *))__pyx_f_6imposm_5cache_2tc_5WayDB__obj; __pyx_type_6imposm_5cache_2tc_WayDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_RefTagDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_WayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_WayDB.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_WayDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_WayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "WayDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_WayDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_WayDB = &__pyx_type_6imposm_5cache_2tc_WayDB; __pyx_vtabptr_6imposm_5cache_2tc_RelationDB = &__pyx_vtable_6imposm_5cache_2tc_RelationDB; __pyx_vtable_6imposm_5cache_2tc_RelationDB.__pyx_base = *__pyx_vtabptr_6imposm_5cache_2tc_RefTagDB; __pyx_vtable_6imposm_5cache_2tc_RelationDB.__pyx_base.__pyx_base._obj = (PyObject *(*)(struct __pyx_obj_6imposm_5cache_2tc_BDB *, int64_t, PyObject *))__pyx_f_6imposm_5cache_2tc_10RelationDB__obj; __pyx_type_6imposm_5cache_2tc_RelationDB.tp_base = __pyx_ptype_6imposm_5cache_2tc_RefTagDB; if (PyType_Ready(&__pyx_type_6imposm_5cache_2tc_RelationDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6imposm_5cache_2tc_RelationDB.tp_print = 0; if (__Pyx_SetVtable(__pyx_type_6imposm_5cache_2tc_RelationDB.tp_dict, __pyx_vtabptr_6imposm_5cache_2tc_RelationDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyObject_SetAttrString(__pyx_m, "RelationDB", (PyObject *)&__pyx_type_6imposm_5cache_2tc_RelationDB) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6imposm_5cache_2tc_RelationDB = &__pyx_type_6imposm_5cache_2tc_RelationDB; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "imposm/cache/tc.pyx":1 * from imposm.base import Node, Way, Relation # <<<<<<<<<<<<<< * from libc.stdint cimport uint32_t, int64_t * */ __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Node); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Node); __Pyx_GIVEREF(__pyx_n_s_Node); __Pyx_INCREF(__pyx_n_s_Way); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_Way); __Pyx_GIVEREF(__pyx_n_s_Way); __Pyx_INCREF(__pyx_n_s_Relation); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Relation); __Pyx_GIVEREF(__pyx_n_s_Relation); __pyx_t_2 = __Pyx_Import(__pyx_n_s_imposm_base, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Node); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Node, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Way); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Way, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Relation); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Relation, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":85 * return p * * _modes = { # <<<<<<<<<<<<<< * 'w': BDBOWRITER | BDBOCREAT, * 'r': BDBOREADER | BDBONOLCK, */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); /* "imposm/cache/tc.pyx":86 * * _modes = { * 'w': BDBOWRITER | BDBOCREAT, # <<<<<<<<<<<<<< * 'r': BDBOREADER | BDBONOLCK, * } */ __pyx_t_1 = __Pyx_PyInt_From_int((BDBOWRITER | BDBOCREAT)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_w, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":87 * _modes = { * 'w': BDBOWRITER | BDBOCREAT, * 'r': BDBOREADER | BDBONOLCK, # <<<<<<<<<<<<<< * } * */ __pyx_t_1 = __Pyx_PyInt_From_int((BDBOREADER | BDBONOLCK)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_r, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_modes, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":312 * return Relation(osmid, data[0], data[1]) * * from imposm.cache.internal import DeltaCoords as _DeltaCoords # <<<<<<<<<<<<<< * from collections import deque * import bisect */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DeltaCoords_2); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DeltaCoords_2); __Pyx_GIVEREF(__pyx_n_s_DeltaCoords_2); __pyx_t_1 = __Pyx_Import(__pyx_n_s_imposm_cache_internal, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_DeltaCoords_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DeltaCoords, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "imposm/cache/tc.pyx":313 * * from imposm.cache.internal import DeltaCoords as _DeltaCoords * from collections import deque # <<<<<<<<<<<<<< * import bisect * */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_deque); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_deque); __Pyx_GIVEREF(__pyx_n_s_deque); __pyx_t_2 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_deque); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_deque, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":314 * from imposm.cache.internal import DeltaCoords as _DeltaCoords * from collections import deque * import bisect # <<<<<<<<<<<<<< * * cdef unzip_nodes(list nodes): */ __pyx_t_2 = __Pyx_Import(__pyx_n_s_bisect, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_bisect, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":353 * return nodes * * class DeltaNodes(object): # <<<<<<<<<<<<<< * def __init__(self, data=None): * self.nodes = [] */ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_builtin_object); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_object); __Pyx_GIVEREF(__pyx_builtin_object); __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_DeltaNodes, __pyx_n_s_DeltaNodes, (PyObject *) NULL, __pyx_n_s_imposm_cache_tc, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); /* "imposm/cache/tc.pyx":354 * * class DeltaNodes(object): * def __init__(self, data=None): # <<<<<<<<<<<<<< * self.nodes = [] * self.changed = False */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_1__init__, 0, __pyx_n_s_DeltaNodes___init, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__3)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":360 * self.deserialize(data) * * def changed(self): # <<<<<<<<<<<<<< * return self.changed * */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_3changed, 0, __pyx_n_s_DeltaNodes_changed, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 360; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_changed, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 360; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":363 * return self.changed * * def get(self, int64_t osmid): # <<<<<<<<<<<<<< * i = bisect.bisect(self.nodes, (osmid, )) * if i != len(self.nodes) and self.nodes[i][0] == osmid: */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_5get, 0, __pyx_n_s_DeltaNodes_get, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__8)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_get, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":369 * return None * * def add(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * # todo: overwrite * self.changed = True */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_7add, 0, __pyx_n_s_DeltaNodes_add, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_add, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":377 * bisect.insort(self.nodes, (osmid, lon, lat)) * * def serialize(self): # <<<<<<<<<<<<<< * ids, lons, lats = unzip_nodes(self.nodes) * nodes = _DeltaCoords() */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_9serialize, 0, __pyx_n_s_DeltaNodes_serialize, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 377; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_serialize, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 377; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":385 * return nodes.SerializeToString() * * def deserialize(self, data): # <<<<<<<<<<<<<< * nodes = _DeltaCoords() * nodes.ParseFromString(data) */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_10DeltaNodes_11deserialize, 0, __pyx_n_s_DeltaNodes_deserialize, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_deserialize, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":353 * return nodes * * class DeltaNodes(object): # <<<<<<<<<<<<<< * def __init__(self, data=None): * self.nodes = [] */ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_DeltaNodes, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DeltaNodes, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":391 * nodes.ids, nodes.lons, nodes.lats) * * class DeltaCoordsDB(object): # <<<<<<<<<<<<<< * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): * self.db = BDB(filename, mode, estimated_records) */ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_builtin_object); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_object); __Pyx_GIVEREF(__pyx_builtin_object); __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_DeltaCoordsDB, __pyx_n_s_DeltaCoordsDB, (PyObject *) NULL, __pyx_n_s_imposm_cache_tc, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); /* "imposm/cache/tc.pyx":392 * * class DeltaCoordsDB(object): * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): # <<<<<<<<<<<<<< * self.db = BDB(filename, mode, estimated_records) * self.mode = mode */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_1__init__, 0, __pyx_n_s_DeltaCoordsDB___init, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__16)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__17); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":400 * self.delta_nodes_size = delta_nodes_size * * def put(self, int64_t osmid, double lon, double lat): # <<<<<<<<<<<<<< * if self.mode == 'r': * return None */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_3put, 0, __pyx_n_s_DeltaCoordsDB_put, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__19)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_put_2, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":410 * return True * * put_marshaled = put # <<<<<<<<<<<<<< * * def get(self, osmid): */ __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_n_s_put_2); if (unlikely(!__pyx_t_4)) { PyErr_Clear(); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_put_2); } if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_put_marshaled, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":412 * put_marshaled = put * * def get(self, osmid): # <<<<<<<<<<<<<< * delta_id = osmid >> self.delta_nodes_size * if delta_id not in self.delta_nodes: */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_5get, 0, __pyx_n_s_DeltaCoordsDB_get, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_get, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 412; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":418 * return self.delta_nodes[delta_id].get(osmid) * * def get_coords(self, osmids): # <<<<<<<<<<<<<< * coords = [] * for osmid in osmids: */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_7get_coords, 0, __pyx_n_s_DeltaCoordsDB_get_coords, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_get_coords, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":427 * return coords * * def close(self): # <<<<<<<<<<<<<< * for node_id, node in self.delta_nodes.iteritems(): * self._put(node_id, node) */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_9close, 0, __pyx_n_s_DeltaCoordsDB_close, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__25)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_close, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 427; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":434 * self.db.close() * * def _put(self, delta_id, delta_node): # <<<<<<<<<<<<<< * data = delta_node.serialize() * self.db.put_marshaled(delta_id, data) */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_11_put, 0, __pyx_n_s_DeltaCoordsDB__put, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__27)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_put, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":438 * self.db.put_marshaled(delta_id, data) * * def _get(self, delta_id): # <<<<<<<<<<<<<< * return DeltaNodes(data=self.db.get_raw(delta_id)) * */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_13_get, 0, __pyx_n_s_DeltaCoordsDB__get, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__29)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_get_2, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 438; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":441 * return DeltaNodes(data=self.db.get_raw(delta_id)) * * def fetch_delta_node(self, delta_id): # <<<<<<<<<<<<<< * if len(self.delta_node_ids) >= self.delta_nodes_cache_size: * rm_id = self.delta_node_ids.popleft() */ __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6imposm_5cache_2tc_13DeltaCoordsDB_15fetch_delta_node, 0, __pyx_n_s_DeltaCoordsDB_fetch_delta_node, NULL, __pyx_n_s_imposm_cache_tc, __pyx_d, ((PyObject *)__pyx_codeobj__31)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_fetch_delta_node, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "imposm/cache/tc.pyx":391 * nodes.ids, nodes.lons, nodes.lats) * * class DeltaCoordsDB(object): # <<<<<<<<<<<<<< * def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): * self.db = BDB(filename, mode, estimated_records) */ __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_DeltaCoordsDB, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_d, __pyx_n_s_DeltaCoordsDB, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "imposm/cache/tc.pyx":1 * from imposm.base import Node, Way, Relation # <<<<<<<<<<<<<< * from libc.stdint cimport uint32_t, int64_t * */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init imposm.cache.tc", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init imposm.cache.tc"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* Runtime support code */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject* args = PyTuple_Pack(1, arg); return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; } #endif static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON result = PyDict_GetItem(__pyx_d, name); if (likely(result)) { Py_INCREF(result); } else { #else result = PyObject_GetItem(__pyx_d, name); if (!result) { PyErr_Clear(); #endif result = __Pyx_GetBuiltinName(name); } return result; } static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_Restore(type, value, tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(type, value, tb); #endif } #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { if (PyObject_IsSubclass(instance_class, type)) { type = instance_class; } else { instance_class = NULL; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } #if PY_VERSION_HEX >= 0x03030000 if (cause) { #else if (cause && cause != Py_None) { #endif PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(tmp_type, tmp_value, tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = PyThreadState_GET(); PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_Clear(); else return NULL; } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_COMPILING_IN_CPYTHON PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_Clear(); else goto bad; } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_COMPILING_IN_CPYTHON result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { PyObject *method, *result = NULL; method = __Pyx_PyObject_GetAttrStr(obj, method_name); if (unlikely(!method)) goto bad; #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyMethod_Check(method))) { PyObject *self = PyMethod_GET_SELF(method); if (likely(self)) { PyObject *args; PyObject *function = PyMethod_GET_FUNCTION(method); args = PyTuple_New(2); if (unlikely(!args)) goto bad; Py_INCREF(self); PyTuple_SET_ITEM(args, 0, self); Py_INCREF(arg); PyTuple_SET_ITEM(args, 1, arg); Py_INCREF(function); Py_DECREF(method); method = NULL; result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); return result; } } #endif result = __Pyx_PyObject_CallOneArg(method, arg); bad: Py_XDECREF(method); return result; } static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { if (likely(PyList_CheckExact(L))) { if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; } else { PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); if (unlikely(!retval)) return -1; Py_DECREF(retval); } return 0; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { PyObject *method, *result = NULL; method = __Pyx_PyObject_GetAttrStr(obj, method_name); if (unlikely(!method)) goto bad; #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyMethod_Check(method))) { PyObject *self = PyMethod_GET_SELF(method); if (likely(self)) { PyObject *function = PyMethod_GET_FUNCTION(method); result = __Pyx_PyObject_CallOneArg(function, self); Py_DECREF(method); return result; } } #endif result = __Pyx_PyObject_CallNoArg(method); Py_DECREF(method); bad: return result; } static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); } static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { if (t == Py_None) { __Pyx_RaiseNoneNotIterableError(); } else if (PyTuple_GET_SIZE(t) < index) { __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); } else { __Pyx_RaiseTooManyValuesError(index); } } static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int is_tuple, int has_known_size, int decref_tuple) { Py_ssize_t index; PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; if (!is_tuple && unlikely(!PyTuple_Check(tuple))) { iternextfunc iternext; iter = PyObject_GetIter(tuple); if (unlikely(!iter)) goto bad; if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } iternext = Py_TYPE(iter)->tp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); } else { if (!has_known_size && unlikely(PyTuple_GET_SIZE(tuple) != 2)) { __Pyx_UnpackTupleError(tuple, 2); goto bad; } #if CYTHON_COMPILING_IN_PYPY value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; #else value1 = PyTuple_GET_ITEM(tuple, 0); value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value1); Py_INCREF(value2); #endif if (decref_tuple) { Py_DECREF(tuple); } } *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; #if !CYTHON_COMPILING_IN_PYPY if (is_dict) { *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; } #endif *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* iter_obj, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); for (i=0; i < nbases; i++) { PyTypeObject *tmptype; PyObject *tmp = PyTuple_GET_ITEM(bases, i); tmptype = Py_TYPE(tmp); #if PY_MAJOR_VERSION < 3 if (tmptype == &PyClass_Type) continue; #endif if (!metaclass) { metaclass = tmptype; continue; } if (PyType_IsSubtype(metaclass, tmptype)) continue; if (PyType_IsSubtype(tmptype, metaclass)) { metaclass = tmptype; continue; } PyErr_SetString(PyExc_TypeError, "metaclass conflict: " "the metaclass of a derived class " "must be a (non-strict) subclass " "of the metaclasses of all its bases"); return NULL; } if (!metaclass) { #if PY_MAJOR_VERSION < 3 metaclass = &PyClass_Type; #else metaclass = &PyType_Type; #endif } Py_INCREF((PyObject*) metaclass); return (PyObject*) metaclass; } static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } static PyObject * __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) { if (unlikely(op->func_doc == NULL)) { if (op->func.m_ml->ml_doc) { #if PY_MAJOR_VERSION >= 3 op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); #else op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); #endif if (unlikely(op->func_doc == NULL)) return NULL; } else { Py_INCREF(Py_None); return Py_None; } } Py_INCREF(op->func_doc); return op->func_doc; } static int __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp = op->func_doc; if (value == NULL) { value = Py_None; } Py_INCREF(value); op->func_doc = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) { if (unlikely(op->func_name == NULL)) { #if PY_MAJOR_VERSION >= 3 op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); #else op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); #endif if (unlikely(op->func_name == NULL)) return NULL; } Py_INCREF(op->func_name); return op->func_name; } static int __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = op->func_name; Py_INCREF(value); op->func_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) { Py_INCREF(op->func_qualname); return op->func_qualname; } static int __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) { #else if (unlikely(value == NULL || !PyString_Check(value))) { #endif PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = op->func_qualname; Py_INCREF(value); op->func_qualname = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) { PyObject *self; self = m->func_closure; if (self == NULL) self = Py_None; Py_INCREF(self); return self; } static PyObject * __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) { if (unlikely(op->func_dict == NULL)) { op->func_dict = PyDict_New(); if (unlikely(op->func_dict == NULL)) return NULL; } Py_INCREF(op->func_dict); return op->func_dict; } static int __Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) { PyObject *tmp; if (unlikely(value == NULL)) { PyErr_SetString(PyExc_TypeError, "function's dictionary may not be deleted"); return -1; } if (unlikely(!PyDict_Check(value))) { PyErr_SetString(PyExc_TypeError, "setting function's dictionary to a non-dict"); return -1; } tmp = op->func_dict; Py_INCREF(value); op->func_dict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) { Py_INCREF(op->func_globals); return op->func_globals; } static PyObject * __Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) { Py_INCREF(Py_None); return Py_None; } static PyObject * __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) { PyObject* result = (op->func_code) ? op->func_code : Py_None; Py_INCREF(result); return result; } static int __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { PyObject *res = op->defaults_getter((PyObject *) op); if (unlikely(!res)) return -1; op->defaults_tuple = PyTuple_GET_ITEM(res, 0); Py_INCREF(op->defaults_tuple); op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); Py_INCREF(op->defaults_kwdict); Py_DECREF(res); return 0; } static int __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyTuple_Check(value)) { PyErr_SetString(PyExc_TypeError, "__defaults__ must be set to a tuple object"); return -1; } Py_INCREF(value); tmp = op->defaults_tuple; op->defaults_tuple = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_tuple; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_tuple; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value) { value = Py_None; } else if (value != Py_None && !PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__kwdefaults__ must be set to a dict object"); return -1; } Py_INCREF(value); tmp = op->defaults_kwdict; op->defaults_kwdict = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { PyObject* result = op->defaults_kwdict; if (unlikely(!result)) { if (op->defaults_getter) { if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; result = op->defaults_kwdict; } else { result = Py_None; } } Py_INCREF(result); return result; } static int __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { PyObject* tmp; if (!value || value == Py_None) { value = NULL; } else if (!PyDict_Check(value)) { PyErr_SetString(PyExc_TypeError, "__annotations__ must be set to a dict object"); return -1; } Py_XINCREF(value); tmp = op->func_annotations; op->func_annotations = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { PyObject* result = op->func_annotations; if (unlikely(!result)) { result = PyDict_New(); if (unlikely(!result)) return NULL; op->func_annotations = result; } Py_INCREF(result); return result; } static PyGetSetDef __pyx_CyFunction_getsets[] = { {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, {0, 0, 0, 0, 0} }; #ifndef PY_WRITE_RESTRICTED #define PY_WRITE_RESTRICTED WRITE_RESTRICTED #endif static PyMemberDef __pyx_CyFunction_members[] = { {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyObject * __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromString(m->func.m_ml->ml_name); #else return PyString_FromString(m->func.m_ml->ml_name); #endif } static PyMethodDef __pyx_CyFunction_methods[] = { {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, {0, 0, 0, 0} }; #if PY_VERSION_HEX < 0x030500A0 #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) #else #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) #endif static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); if (op == NULL) return NULL; op->flags = flags; __Pyx_CyFunction_weakreflist(op) = NULL; op->func.m_ml = ml; op->func.m_self = (PyObject *) op; Py_XINCREF(closure); op->func_closure = closure; Py_XINCREF(module); op->func.m_module = module; op->func_dict = NULL; op->func_name = NULL; Py_INCREF(qualname); op->func_qualname = qualname; op->func_doc = NULL; op->func_classobj = NULL; op->func_globals = globals; Py_INCREF(op->func_globals); Py_XINCREF(code); op->func_code = code; op->defaults_pyobjects = 0; op->defaults = NULL; op->defaults_tuple = NULL; op->defaults_kwdict = NULL; op->defaults_getter = NULL; op->func_annotations = NULL; PyObject_GC_Track(op); return (PyObject *) op; } static int __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) { Py_CLEAR(m->func_closure); Py_CLEAR(m->func.m_module); Py_CLEAR(m->func_dict); Py_CLEAR(m->func_name); Py_CLEAR(m->func_qualname); Py_CLEAR(m->func_doc); Py_CLEAR(m->func_globals); Py_CLEAR(m->func_code); Py_CLEAR(m->func_classobj); Py_CLEAR(m->defaults_tuple); Py_CLEAR(m->defaults_kwdict); Py_CLEAR(m->func_annotations); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_XDECREF(pydefaults[i]); PyMem_Free(m->defaults); m->defaults = NULL; } return 0; } static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) { PyObject_GC_UnTrack(m); if (__Pyx_CyFunction_weakreflist(m) != NULL) PyObject_ClearWeakRefs((PyObject *) m); __Pyx_CyFunction_clear(m); PyObject_GC_Del(m); } static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) { Py_VISIT(m->func_closure); Py_VISIT(m->func.m_module); Py_VISIT(m->func_dict); Py_VISIT(m->func_name); Py_VISIT(m->func_qualname); Py_VISIT(m->func_doc); Py_VISIT(m->func_globals); Py_VISIT(m->func_code); Py_VISIT(m->func_classobj); Py_VISIT(m->defaults_tuple); Py_VISIT(m->defaults_kwdict); if (m->defaults) { PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); int i; for (i = 0; i < m->defaults_pyobjects; i++) Py_VISIT(pydefaults[i]); } return 0; } static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { Py_INCREF(func); return func; } if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { if (type == NULL) type = (PyObject *)(Py_TYPE(obj)); return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); } if (obj == Py_None) obj = NULL; return __Pyx_PyMethod_New(func, obj, type); } static PyObject* __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) { #if PY_MAJOR_VERSION >= 3 return PyUnicode_FromFormat("", op->func_qualname, (void *)op); #else return PyString_FromFormat("", PyString_AsString(op->func_qualname), (void *)op); #endif } #if CYTHON_COMPILING_IN_PYPY static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyCFunctionObject* f = (PyCFunctionObject*)func; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); Py_ssize_t size; switch (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)) { case METH_VARARGS: if (likely(kw == NULL) || PyDict_Size(kw) == 0) return (*meth)(self, arg); break; case METH_VARARGS | METH_KEYWORDS: return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); case METH_NOARGS: if (likely(kw == NULL) || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 0) return (*meth)(self, NULL); PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments (%zd given)", f->m_ml->ml_name, size); return NULL; } break; case METH_O: if (likely(kw == NULL) || PyDict_Size(kw) == 0) { size = PyTuple_GET_SIZE(arg); if (size == 1) return (*meth)(self, PyTuple_GET_ITEM(arg, 0)); PyErr_Format(PyExc_TypeError, "%.200s() takes exactly one argument (%zd given)", f->m_ml->ml_name, size); return NULL; } break; default: PyErr_SetString(PyExc_SystemError, "Bad call flags in " "__Pyx_CyFunction_Call. METH_OLDARGS is no " "longer supported!"); return NULL; } PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", f->m_ml->ml_name); return NULL; } #else static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { return PyCFunction_Call(func, arg, kw); } #endif static PyTypeObject __pyx_CyFunctionType_type = { PyVarObject_HEAD_INIT(0, 0) "cython_function_or_method", sizeof(__pyx_CyFunctionObject), 0, (destructor) __Pyx_CyFunction_dealloc, 0, 0, 0, #if PY_MAJOR_VERSION < 3 0, #else 0, #endif (reprfunc) __Pyx_CyFunction_repr, 0, 0, 0, 0, __Pyx_CyFunction_Call, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, 0, (traverseproc) __Pyx_CyFunction_traverse, (inquiry) __Pyx_CyFunction_clear, 0, #if PY_VERSION_HEX < 0x030500A0 offsetof(__pyx_CyFunctionObject, func_weakreflist), #else offsetof(PyCFunctionObject, m_weakreflist), #endif 0, 0, __pyx_CyFunction_methods, __pyx_CyFunction_members, __pyx_CyFunction_getsets, 0, 0, __Pyx_CyFunction_descr_get, 0, offsetof(__pyx_CyFunctionObject, func_dict), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif }; static int __Pyx_CyFunction_init(void) { #if !CYTHON_COMPILING_IN_PYPY __pyx_CyFunctionType_type.tp_call = PyCFunction_Call; #endif __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); if (__pyx_CyFunctionType == NULL) { return -1; } return 0; } static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults = PyMem_Malloc(size); if (!m->defaults) return PyErr_NoMemory(); memset(m->defaults, 0, size); m->defaults_pyobjects = pyobjects; return m->defaults; } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_tuple = tuple; Py_INCREF(tuple); } static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->defaults_kwdict = dict; Py_INCREF(dict); } static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; m->func_annotations = dict; Py_INCREF(dict); } static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { PyObject *ns; if (metaclass) { PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); if (prep) { PyObject *pargs = PyTuple_Pack(2, name, bases); if (unlikely(!pargs)) { Py_DECREF(prep); return NULL; } ns = PyObject_Call(prep, pargs, mkw); Py_DECREF(prep); Py_DECREF(pargs); } else { if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; PyErr_Clear(); ns = PyDict_New(); } } else { ns = PyDict_New(); } if (unlikely(!ns)) return NULL; if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; return ns; bad: Py_DECREF(ns); return NULL; } static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass) { PyObject *result, *margs; PyObject *owned_metaclass = NULL; if (allow_py2_metaclass) { owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); if (owned_metaclass) { metaclass = owned_metaclass; } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { PyErr_Clear(); } else { return NULL; } } if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); Py_XDECREF(owned_metaclass); if (unlikely(!metaclass)) return NULL; owned_metaclass = metaclass; } margs = PyTuple_Pack(3, name, bases, dict); if (unlikely(!margs)) { result = NULL; } else { result = PyObject_Call(metaclass, margs, mkw); Py_DECREF(margs); } Py_XDECREF(owned_metaclass); return result; } static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = (start + end) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; py_code = __pyx_find_code_object(c_line ? c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? c_line : py_line, py_code); } py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = py_line; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_VERSION_HEX < 0x03030000 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(1); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_VERSION_HEX < 0x03030000 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(int) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ { \ func_type value = func_value; \ if (sizeof(target_type) < sizeof(func_type)) { \ if (unlikely(value != (func_type) (target_type) value)) { \ func_type zero = 0; \ if (is_unsigned && unlikely(value < zero)) \ goto raise_neg_overflow; \ else \ goto raise_overflow; \ } \ } \ return (target_type) value; \ } #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #endif #endif static CYTHON_INLINE int64_t __Pyx_PyInt_As_int64_t(PyObject *x) { const int64_t neg_one = (int64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int64_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(int64_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int64_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(int64_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int64_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(int64_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(int64_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(int64_t, long, PyLong_AsLong(x)) } else if (sizeof(int64_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(int64_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int64_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int64_t) -1; } } else { int64_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (int64_t) -1; val = __Pyx_PyInt_As_int64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int64_t"); return (int64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int64_t"); return (int64_t) -1; } static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(int, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value) { const int64_t neg_one = (int64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(int64_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(int64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int64_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int64_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { const uint32_t neg_one = (uint32_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint32_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uint32_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint32_t), little, !is_unsigned); } } static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { const uint32_t neg_one = (uint32_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint32_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint32_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uint32_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uint32_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint32_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uint32_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uint32_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint32_t, long, PyLong_AsLong(x)) } else if (sizeof(uint32_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uint32_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uint32_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uint32_t) -1; } } else { uint32_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uint32_t) -1; val = __Pyx_PyInt_As_uint32_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint32_t"); return (uint32_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint32_t"); return (uint32_t) -1; } static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { #if PY_VERSION_HEX < 0x03030000 char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; #else if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (PyUnicode_IS_ASCII(o)) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif #endif } else #endif #if !CYTHON_COMPILING_IN_PYPY if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { PyNumberMethods *m; const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return Py_INCREF(x), x; m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) return PyInt_AS_LONG(b); #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(b)) { case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; case 0: return 0; case 1: return ((PyLongObject*)b)->ob_digit[0]; } #endif #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ imposm-2.6.0/imposm/cache/tc.pyx0000644000076500000240000003351112454176055016477 0ustar oltstaff00000000000000from imposm.base import Node, Way, Relation from libc.stdint cimport uint32_t, int64_t cdef extern from "Python.h": object PyString_FromStringAndSize(char *s, Py_ssize_t len) cdef extern from "marshal.h": object PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len) object PyMarshal_WriteObjectToString(object value, int version) cdef extern from "tcutil.h": ctypedef int TCCMP() cdef int tccmpint32() cdef int tccmpint64() cdef extern from "tcbdb.h": ctypedef enum: BDBFOPEN BDBFFATAL ctypedef enum: BDBOREADER = 1 << 0 # /* open as a reader */ BDBOWRITER = 1 << 1 # /* open as a writer */ BDBOCREAT = 1 << 2 # /* writer creating */ BDBOTRUNC = 1 << 3 # /* writer truncating */ BDBONOLCK = 1 << 4 # /* open without locking */ BDBOLCKNB = 1 << 5 # /* lock without blocking */ BDBOTSYNC = 1 << 6 # /* synchronize every transaction */ ctypedef enum: BDBTLARGE = 1 << 0, # /* use 64-bit bucket array */ BDBTDEFLATE = 1 << 1 # /* compress each page with Deflate */ BDBTBZIP = 1 << 2, # /* compress each record with BZIP2 */ BDBTTCBS = 1 << 3, # /* compress each page with TCBS */ BDBTEXCODEC = 1 << 4 # /* compress each record with outer functions */ ctypedef void TCBDB ctypedef void BDBCUR TCBDB *tcbdbnew() void tcbdbdel(TCBDB *) int tcbdbecode(TCBDB *) bint tcbdbtune(TCBDB *db, int lmemb, int nmemb, int bnum, int apow, int fpow, int opts) bint tcbdbsetcache(TCBDB *bdb, int lcnum, int ncnum) bint tcbdbsetcmpfunc(TCBDB *bdb, TCCMP cmp, void *cmpop) bint tcbdbsetmutex(TCBDB *bdb) bint tcbdbopen(TCBDB *, char *, int) bint tcbdbclose(TCBDB *) nogil bint tcbdbput(TCBDB *, void *, int, void *, int) nogil void *tcbdbget(TCBDB *, void *, int, int *) nogil void *tcbdbget3(TCBDB *bdb, void *kbuf, int ksiz, int *sp) nogil long tcbdbrnum(TCBDB *bdb) BDBCUR *tcbdbcurnew(TCBDB *bdb) void tcbdbcurdel(BDBCUR *cur) bint tcbdbcurfirst(BDBCUR *cur) bint tcbdbcurnext(BDBCUR *cur) void *tcbdbcurkey3(BDBCUR *cur, int *sp) void *tcbdbcurval3(BDBCUR *cur, int *sp) DEF COORD_FACTOR = 11930464.7083 # ((2<<31)-1)/360.0 cdef uint32_t _coord_to_uint32(double x) nogil: return ((x + 180.0) * COORD_FACTOR) cdef double _uint32_to_coord(uint32_t x) nogil: return ((x / COORD_FACTOR) - 180.0) ctypedef struct coord: uint32_t x uint32_t y cdef inline coord coord_struct(double x, double y) nogil: cdef coord p p.x = _coord_to_uint32(x) p.y = _coord_to_uint32(y) return p _modes = { 'w': BDBOWRITER | BDBOCREAT, 'r': BDBOREADER | BDBONOLCK, } cdef class BDB: cdef TCBDB *db cdef object filename cdef int _opened cdef BDBCUR *_cur def __cinit__(self, filename, mode='w', estimated_records=0): self.db = tcbdbnew() self._opened = 0 def __init__(self, filename, mode='w', estimated_records=0): self.filename = filename self._tune_db(estimated_records) tcbdbsetcmpfunc(self.db, tccmpint64, NULL) if not tcbdbopen(self.db, filename, _modes[mode]): raise IOError(tcbdbecode(self.db)) self._opened = 1 def _tune_db(self, estimated_records): if estimated_records: lmemb = 128 # default nmemb = -1 fpow = 13 # 2^13 = 8196 bnum = int((estimated_records*3)/lmemb) tcbdbtune(self.db, lmemb, nmemb, bnum, 5, fpow, BDBTLARGE | BDBTDEFLATE) else: tcbdbtune(self.db, -1, -1, -1, 5, 13, BDBTLARGE | BDBTDEFLATE) def get(self, int64_t osmid): """ Return object with given id. Returns None if id is not stored. """ cdef void *ret cdef int ret_size ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) if not ret: return None return self._obj(osmid, PyMarshal_ReadObjectFromString(ret, ret_size)) def get_raw(self, int64_t osmid): """ Return object with given id. Returns None if id is not stored. """ cdef void *ret cdef int ret_size ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) if not ret: return None return PyString_FromStringAndSize(ret, ret_size) def put(self, int64_t osmid, data): return self.put_marshaled(osmid, PyMarshal_WriteObjectToString(data, 2)) def put_marshaled(self, int64_t osmid, data): return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) cdef object _obj(self, int64_t osmid, data): """ Create an object from the id and unmarshaled data. Should be overridden by subclasses. """ return data def __iter__(self): """ Return an iterator over the database. Resets any existing iterator. """ if self._cur: tcbdbcurdel(self._cur) self._cur = tcbdbcurnew(self.db) if not tcbdbcurfirst(self._cur): return iter([]) return self def __contains__(self, int64_t osmid): cdef void *ret cdef int ret_size ret = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size); if ret: return 1 else: return 0 def __len__(self): return tcbdbrnum(self.db) def __next__(self): """ Return next item as object. """ cdef int64_t osmid if not self._cur: raise StopIteration osmid, data = self._get_cur() # advance cursor, set to NULL if at the end if tcbdbcurnext(self._cur) == 0: tcbdbcurdel(self._cur) self._cur = NULL # return objectified item return self._obj(osmid, data) cdef object _get_cur(self): """ Return the current object at the current cursor position as a tuple of the id and the unmarshaled data. """ cdef int size cdef void *ret ret = tcbdbcurkey3(self._cur, &size) osmid = (ret)[0] ret = tcbdbcurval3(self._cur, &size) value = PyMarshal_ReadObjectFromString(ret, size) return osmid, value def close(self): if self._opened: tcbdbclose(self.db) self._opened = 0 def __dealloc__(self): if self._opened: tcbdbclose(self.db) tcbdbdel(self.db) cdef class CoordDB(BDB): def put(self, osmid, x, y): return self._put(osmid, x, y) def put_marshaled(self, osmid, x, y): return self._put(osmid, x, y) cdef bint _put(self, int64_t osmid, double x, double y) nogil: cdef coord p = coord_struct(x, y) return tcbdbput(self.db, &osmid, sizeof(int64_t), &p, sizeof(coord)) def get(self, int64_t osmid): cdef coord *value cdef int ret_size value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) if not value: return return _uint32_to_coord(value.x), _uint32_to_coord(value.y) def get_coords(self, refs): cdef coord *value cdef int ret_size cdef int64_t osmid coords = list() for osmid in refs: value = tcbdbget3(self.db, &osmid, sizeof(int64_t), &ret_size) if not value: return coords.append((_uint32_to_coord(value.x), _uint32_to_coord(value.y))) return coords cdef object _get_cur(self): cdef int size cdef int64_t osmid cdef void *ret cdef coord *value ret = tcbdbcurkey3(self._cur, &size) osmid = (ret)[0] value = tcbdbcurval3(self._cur, &size) return osmid, (_uint32_to_coord(value.x), _uint32_to_coord(value.y)) cdef object _obj(self, int64_t osmid, data): return osmid, data cdef class NodeDB(BDB): def put(self, osmid, tags, pos): return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, pos), 2)) def put_marshaled(self, int64_t osmid, data): return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) cdef object _obj(self, int64_t osmid, data): return Node(osmid, data[0], data[1]) cdef class InsertedWayDB(BDB): def put(self, int64_t osmid): return tcbdbput(self.db, &osmid, sizeof(int64_t), 'x', 1); def __next__(self): """ Return next item as object. """ cdef int64_t osmid cdef int size cdef void *ret if not self._cur: raise StopIteration ret = tcbdbcurkey3(self._cur, &size) osmid = (ret)[0] # advance cursor, set to NULL if at the end if tcbdbcurnext(self._cur) == 0: tcbdbcurdel(self._cur) self._cur = NULL return osmid cdef class RefTagDB(BDB): """ Database for items with references and tags (i.e. ways/relations). """ def put(self, osmid, tags, refs): return self.put_marshaled(osmid, PyMarshal_WriteObjectToString((tags, refs), 2)) def put_marshaled(self, int64_t osmid, data): return tcbdbput(self.db, &osmid, sizeof(int64_t), data, len(data)) cdef class WayDB(RefTagDB): cdef object _obj(self, int64_t osmid, data): return Way(osmid, data[0], data[1]) cdef class RelationDB(RefTagDB): cdef object _obj(self, int64_t osmid, data): return Relation(osmid, data[0], data[1]) from imposm.cache.internal import DeltaCoords as _DeltaCoords from collections import deque import bisect cdef unzip_nodes(list nodes): cdef int64_t last_lon, last_lat, lon, lat cdef double lon_f, lat_f cdef int64_t last_id, id ids, lons, lats = [], [], [] last_id = last_lon = last_lat = 0 for id, lon_f, lat_f in nodes: lon = _coord_to_uint32(lon_f) lat = _coord_to_uint32(lat_f) ids.append(id - last_id) lons.append(lon - last_lon) lats.append(lat - last_lat) last_id = id last_lon = lon last_lat = lat return ids, lons, lats cdef zip_nodes(tuple ids, tuple lons, tuple lats): cdef uint32_t last_lon, last_lat cdef int64_t last_id nodes = [] last_id = last_lon = last_lat = 0 for i in range(len(ids)): last_id += ids[i] last_lon += lons[i] last_lat += lats[i] nodes.append(( last_id, _uint32_to_coord(last_lon), _uint32_to_coord(last_lat) )) return nodes class DeltaNodes(object): def __init__(self, data=None): self.nodes = [] self.changed = False if data: self.deserialize(data) def changed(self): return self.changed def get(self, int64_t osmid): i = bisect.bisect(self.nodes, (osmid, )) if i != len(self.nodes) and self.nodes[i][0] == osmid: return self.nodes[i][1:] return None def add(self, int64_t osmid, double lon, double lat): # todo: overwrite self.changed = True if self.nodes and self.nodes[-1][0] < osmid: self.nodes.append((osmid, lon, lat)) else: bisect.insort(self.nodes, (osmid, lon, lat)) def serialize(self): ids, lons, lats = unzip_nodes(self.nodes) nodes = _DeltaCoords() nodes.ids = ids nodes.lons = lons nodes.lats = lats return nodes.SerializeToString() def deserialize(self, data): nodes = _DeltaCoords() nodes.ParseFromString(data) self.nodes = zip_nodes( nodes.ids, nodes.lons, nodes.lats) class DeltaCoordsDB(object): def __init__(self, filename, mode='w', estimated_records=0, delta_nodes_cache_size=100, delta_nodes_size=6): self.db = BDB(filename, mode, estimated_records) self.mode = mode self.delta_nodes = {} self.delta_node_ids = deque() self.delta_nodes_cache_size = delta_nodes_cache_size self.delta_nodes_size = delta_nodes_size def put(self, int64_t osmid, double lon, double lat): if self.mode == 'r': return None delta_id = osmid >> self.delta_nodes_size if delta_id not in self.delta_nodes: self.fetch_delta_node(delta_id) delta_node = self.delta_nodes[delta_id] delta_node.add(osmid, lon, lat) return True put_marshaled = put def get(self, osmid): delta_id = osmid >> self.delta_nodes_size if delta_id not in self.delta_nodes: self.fetch_delta_node(delta_id) return self.delta_nodes[delta_id].get(osmid) def get_coords(self, osmids): coords = [] for osmid in osmids: coord = self.get(osmid) if coord is None: return coords.append(coord) return coords def close(self): for node_id, node in self.delta_nodes.iteritems(): self._put(node_id, node) self.delta_nodes = {} self.delta_node_ids = deque() self.db.close() def _put(self, delta_id, delta_node): data = delta_node.serialize() self.db.put_marshaled(delta_id, data) def _get(self, delta_id): return DeltaNodes(data=self.db.get_raw(delta_id)) def fetch_delta_node(self, delta_id): if len(self.delta_node_ids) >= self.delta_nodes_cache_size: rm_id = self.delta_node_ids.popleft() rm_node = self.delta_nodes.pop(rm_id) if rm_node.changed: self._put(rm_id, rm_node) new_node = self._get(delta_id) if new_node is None: new_node = DeltaNodes() self.delta_nodes[delta_id] = new_node self.delta_node_ids.append(delta_id) imposm-2.6.0/imposm/config.py0000644000076500000240000000251411766043214016075 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import relations with missing rings import_partial_relations = False # select relation builder: union or contains relation_builder = 'contains' # log relation that take longer than x seconds imposm_multipolygon_report = 60 # skip relations with more rings (0 skip nothing) imposm_multipolygon_max_ring = 0 # split ways that are longer than x nodes (0 to split nothing) imposm_linestring_max_length = 0 # create a SERIAL PRIMARY KEY column (id) for all Postgres tables # solves cases where osm_id is not unique (e.g. tram and road share the # same way and are combined in a union view) imposm_pg_serial_id = True # cache coords in a compact storage (with delta encoding) # use this when memory is limited (default) imposm_compact_coords_cache = Trueimposm-2.6.0/imposm/db/0000755000076500000240000000000012454222732014640 5ustar oltstaff00000000000000imposm-2.6.0/imposm/db/__init__.py0000644000076500000240000000000011766043214016740 0ustar oltstaff00000000000000imposm-2.6.0/imposm/db/config.py0000644000076500000240000000465112236167777016504 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import re import cgi import urllib from . postgis import PostGISDB from .. mapping import Options def DB(db_conf): if db_conf.get('name', 'postgis') == 'postgis': # default and backwards compat return PostGISDB(db_conf) raise ValueError('unknown db: %s' % (db_conf.name,)) def check_connection(db_conf): try: db = DB(db_conf) db.connection except Exception, e: return e def db_conf_from_string(conf, base_db_conf): db_conf = _parse_rfc1738_args(conf) if 'proj' not in db_conf: db_conf.proj = base_db_conf.proj if 'prefix' not in db_conf: db_conf.prefix = base_db_conf.prefix return db_conf def _parse_rfc1738_args(name): # from SQLAlchemy lib/sqlalchemy/engine/url.py # MIT licensed pattern = re.compile(r''' (?P\w+):// (?: (?P[^:/]*) (?::(?P[^/]*))? @)? (?: (?P[^/:]*) (?::(?P[^/]*))? )? (?:/(?P.*))? ''' , re.X) m = pattern.match(name) if m is not None: components = m.groupdict() if components['db'] is not None: tokens = components['db'].split('?', 2) components['db'] = tokens[0] query = (len(tokens) > 1 and dict(cgi.parse_qsl(tokens[1]))) or None if query is not None: query = dict((k.encode('ascii'), query[k]) for k in query) else: query = None components['query'] = query if components['password'] is not None: components['password'] = urllib.unquote_plus(components['password']) return Options(**components) else: raise ValueError( "Could not parse rfc1738 URL from string '%s'" % name) imposm-2.6.0/imposm/db/postgis.py0000644000076500000240000005447412454213016016713 0ustar oltstaff00000000000000# Copyright 2011-2012 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import time import uuid from contextlib import contextmanager import psycopg2 import psycopg2.extensions import logging log = logging.getLogger(__name__) from imposm import config from imposm.mapping import UnionView, GeneralizedTable, FixInvalidPolygons, Mapping unknown = object() class PostGISDB(object): insert_data_format = 'tuple' def __init__(self, db_conf, use_geometry_columns_table=unknown): self.db_conf = db_conf self.srid = int(db_conf['proj'].split(':')[1]) self._insert_stmts = {} self._connection = None self._cur = None if use_geometry_columns_table is unknown: if self.is_postgis_2(): use_geometry_columns_table = False else: use_geometry_columns_table = True self.use_geometry_columns_table = use_geometry_columns_table @property def table_prefix(self): if self.db_conf.prefix: return self.db_conf.prefix.rstrip('_') + '_' return self.db_conf.prefix def to_tablename(self, name): return self.table_prefix + name.lower() def is_postgis_2(self): cur = self.connection.cursor() cur.execute('SELECT postgis_version()') version_string = cur.fetchone()[0] return version_string.strip()[0] == '2' @property def connection(self): if not self._connection: kw = {} if self.db_conf.port: kw['port'] = int(self.db_conf.port) self._connection = psycopg2.connect( database=self.db_conf.db, host=self.db_conf.host, user=self.db_conf.user, password=self.db_conf.password, sslmode=self.db_conf.get('sslmode', 'allow'), **kw ) self._connection.set_isolation_level( psycopg2.extensions.ISOLATION_LEVEL_READ_COMMITTED) return self._connection def commit(self): self.connection.commit() @property def cur(self): if self._cur is None: self._cur = self.connection.cursor() return self._cur @contextmanager def savepoint(self, cur, raise_errors=False): savepoint_name = 'savepoint' + uuid.uuid4().get_hex() try: cur.execute('SAVEPOINT %s' % savepoint_name) yield except psycopg2.ProgrammingError: cur.execute('ROLLBACK TO SAVEPOINT %s' % savepoint_name) if raise_errors: raise def insert(self, mapping, insert_data, tries=0): insert_stmt = self.insert_stmt(mapping) try: if tries: self.reconnect() self.cur.executemany(insert_stmt, insert_data) except psycopg2.OperationalError, ex: if tries >= 8: log.warn('%s, giving up', ex) raise seconds = 2 ** (tries + 1) log.warn('%s, retry in %d', ex, seconds) time.sleep(seconds) self.insert(mapping, insert_data, tries=tries + 1) except psycopg2.Error, ex: self.connection.rollback() for data in insert_data: try: self.cur.execute(insert_stmt, data) except psycopg2.Error, ex: log.warn('error while importing "%r": %s', data, ex) self.connection.rollback() else: self.connection.commit() self.connection.commit() def post_insert(self, mappings): mappings = [m for m in mappings.values() if isinstance(m, (GeneralizedTable, Mapping))] for mapping in mappings: table_name = self.to_tablename(mapping.name) self.create_geom_index(table_name) def create_geom_index(self, table_name): idx_name = '%s_geom' % table_name cur = self.connection.cursor() cur.execute(""" CREATE INDEX "%s" ON "%s" USING GIST (geometry) """ % (idx_name,table_name)) self.connection.commit() def geom_wrapper(self, geom): return psycopg2.Binary(geom.wkb) def reconnect(self): if self._connection: try: self._connection.close() except psycopg2.InterfaceError: pass self._connection = None self._cur = None def insert_stmt(self, mapping): if mapping.name not in self._insert_stmts: self._insert_stmts[mapping.name] = self._insert_stmt(mapping) return self._insert_stmts[mapping.name] def _insert_stmt(self, mapping): extra_arg_names = extra_args = '' if mapping.fields: extra_arg_names = [n for n, t in mapping.fields] extra_args = ', %s' * len(extra_arg_names) extra_arg_names = ', ' + ', '.join('"' + name + '"' for name in extra_arg_names) return """INSERT INTO "%(tablename)s" (osm_id, geometry %(extra_arg_names)s) VALUES (%%s, ST_Transform(ST_GeomFromWKB(%%s, 4326), %(srid)s) %(extra_args)s) """.strip() % dict(tablename=self.table_prefix + mapping.name, srid=self.srid, extra_arg_names=extra_arg_names, extra_args=extra_args) def create_tables(self, mappings): for mapping in mappings: self.create_table(mapping) def drop_table_or_view(self, cur, name): with self.savepoint(cur): cur.execute('DROP TABLE "' + name + '" CASCADE') with self.savepoint(cur): cur.execute('DROP VIEW "' + name + '" CASCADE') def create_table(self, mapping): tablename = self.table_prefix + mapping.name cur = self.connection.cursor() self.drop_table_or_view(cur, tablename) extra_fields = '' for n, t in mapping.fields: extra_fields += ', "%s" %s ' % (n, t.column_type) if config.imposm_pg_serial_id: serial_column = "id SERIAL PRIMARY KEY," else: serial_column = "" cur.execute(""" CREATE TABLE "%s" ( %s osm_id BIGINT %s ); """ % (tablename, serial_column, extra_fields)) self.create_geometry_column(cur, tablename, mapping) self.create_field_indices(cur=cur, mapping=mapping, tablename=tablename) def create_geometry_column(self, cur, tablename, mapping): if self.use_geometry_columns_table: cur.execute(""" SELECT AddGeometryColumn ('', '%(tablename)s', 'geometry', %(srid)s, '%(pg_geometry_type)s', 2) """ % dict(tablename=tablename, srid=self.srid, pg_geometry_type=mapping.geom_type)) else: cur.execute(""" ALTER TABLE %(tablename)s ADD COLUMN geometry geometry(%(pg_geometry_type)s, %(srid)s); """ % dict(tablename=tablename, srid=self.srid, pg_geometry_type=mapping.geom_type)) def create_field_indices(self, cur, mapping, tablename): for n, t in mapping.fields: if isinstance(t, TrigramIndex): cur.execute(""" CREATE INDEX "%(tablename)s_trgm_idx_%(column)s" ON "%(tablename)s" USING GIST ("%(column)s" gist_trgm_ops) """ % dict(tablename=tablename, column=n)) if isinstance(t, (StringIndex, Index)): cur.execute(""" CREATE INDEX "%(tablename)s_idx_%(column)s" ON "%(tablename)s" ("%(column)s") """ % dict(tablename=tablename, column=n)) def swap_tables(self, new_prefix, existing_prefix, backup_prefix): cur = self.connection.cursor() # remove views before tables, because remove_tables will also remove # views via CASCADE and we need the view names for cleanup of # geometry_columns self.remove_views(backup_prefix) self.remove_tables(backup_prefix) cur.execute("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename like %s", (existing_prefix + '%', )) existing_tables = [] for row in cur: table_name = row[0] if table_name.startswith(existing_prefix) and not table_name.startswith((new_prefix, backup_prefix)): # check for overlapping prefixes: osm_ but not osm_new_ or osm_backup_ existing_tables.append(table_name) cur.execute("SELECT viewname FROM pg_views WHERE schemaname = 'public' AND viewname like %s", (existing_prefix + '%', )) existing_views = [] for row in cur: view_name = row[0] if view_name.startswith(existing_prefix) and not view_name.startswith((new_prefix, backup_prefix)): # check for overlapping prefixes: osm_ but not osm_new_ or osm_backup_ existing_views.append(view_name) cur.execute("SELECT indexname FROM pg_indexes WHERE schemaname = 'public' AND indexname like %s", (existing_prefix + '%', )) existing_indexes = set() for row in cur: index_name = row[0] if index_name.startswith(existing_prefix) and not index_name.startswith((new_prefix, backup_prefix)): # check for overlapping prefixes: osm_ but not osm_new_ or osm_backup_ existing_indexes.add(index_name) cur.execute('SELECT relname FROM pg_class WHERE relname like %s', (existing_prefix + '%_id_seq', )) existing_seq = set() for row in cur: seq_name = row[0] if seq_name.startswith(existing_prefix) and not seq_name.startswith((new_prefix, backup_prefix)): # check for overlapping prefixes: osm_ but not osm_new_ or osm_backup_ existing_seq.add(seq_name) cur.execute("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename like %s", (new_prefix + '%', )) new_tables = [] for row in cur: table_name = row[0] new_tables.append(table_name) cur.execute("SELECT viewname FROM pg_views WHERE schemaname = 'public' AND viewname like %s", (new_prefix + '%', )) new_views = [] for row in cur: view_name = row[0] new_views.append(view_name) cur.execute("SELECT indexname FROM pg_indexes WHERE schemaname = 'public' AND indexname like %s", (new_prefix + '%', )) new_indexes = set() for row in cur: index_name = row[0] new_indexes.add(index_name) cur.execute('SELECT relname FROM pg_class WHERE relname like %s', (new_prefix + '%_id_seq', )) new_seq = [] for row in cur: seq_name = row[0] new_seq.append(seq_name) if not new_tables: raise RuntimeError('did not found tables to swap') # rename existing tables (osm_) to backup_prefix (osm_backup_) for table_name in existing_tables: rename_to = table_name.replace(existing_prefix, backup_prefix) cur.execute('ALTER TABLE "%s" RENAME TO "%s"' % (table_name, rename_to)) for idx in existing_indexes: if idx in (table_name + '_geom', table_name + '_pkey') or idx.startswith(table_name + '_trgm_idx_') or idx.startswith(table_name + '_idx_'): new_idx = idx.replace(table_name, rename_to, 1) cur.execute('ALTER INDEX "%s" RENAME TO "%s"' % (idx, new_idx)) if table_name + '_id_seq' in existing_seq: cur.execute('ALTER SEQUENCE "%s" RENAME TO "%s"' % (table_name + '_id_seq', rename_to + '_id_seq')) if self.use_geometry_columns_table: cur.execute('UPDATE geometry_columns SET f_table_name = %s WHERE f_table_name = %s', (rename_to, table_name)) # rename existing views (osm_) to backup_prefix (osm_backup_) for view_name in existing_views: rename_to = view_name.replace(existing_prefix, backup_prefix) cur.execute('ALTER VIEW "%s" RENAME TO "%s"' % (view_name, rename_to)) if self.use_geometry_columns_table: cur.execute('UPDATE geometry_columns SET f_table_name = %s WHERE f_table_name = %s', (rename_to, view_name)) # rename new tables (osm_new_) to existing_prefix (osm_) for table_name in new_tables: rename_to = table_name.replace(new_prefix, existing_prefix) cur.execute('ALTER TABLE "%s" RENAME TO "%s"' % (table_name, rename_to)) for idx in new_indexes: if idx in (table_name + '_geom', table_name + '_pkey') or idx.startswith(table_name + '_trgm_idx_') or idx.startswith(table_name + '_idx_'): new_idx = idx.replace(table_name, rename_to, 1) cur.execute('ALTER INDEX "%s" RENAME TO "%s"' % (idx, new_idx)) if table_name + '_id_seq' in new_seq: cur.execute('ALTER SEQUENCE "%s" RENAME TO "%s"' % (table_name + '_id_seq', rename_to + '_id_seq')) if self.use_geometry_columns_table: cur.execute('UPDATE geometry_columns SET f_table_name = %s WHERE f_table_name = %s', (rename_to, table_name)) # rename new views (osm_new_) to existing_prefix (osm_) for view_name in new_views: rename_to = view_name.replace(new_prefix, existing_prefix) cur.execute('ALTER VIEW "%s" RENAME TO "%s"' % (view_name, rename_to)) if self.use_geometry_columns_table: cur.execute('UPDATE geometry_columns SET f_table_name = %s WHERE f_table_name = %s', (rename_to, view_name)) def remove_tables(self, prefix): cur = self.connection.cursor() cur.execute('SELECT tablename FROM pg_tables WHERE tablename like %s', (prefix + '%', )) remove_tables = [row[0] for row in cur] for table_name in remove_tables: cur.execute("DROP TABLE %s CASCADE" % (table_name, )) if self.use_geometry_columns_table: cur.execute("DELETE FROM geometry_columns WHERE f_table_name = %s", (table_name, )) def remove_views(self, prefix): cur = self.connection.cursor() cur.execute('SELECT viewname FROM pg_views WHERE viewname like %s', (prefix + '%', )) remove_views = [row[0] for row in cur] for view_name in remove_views: cur.execute('DROP VIEW "%s" CASCADE' % (view_name, )) if self.use_geometry_columns_table: cur.execute("DELETE FROM geometry_columns WHERE f_table_name = %s", (view_name, )) def create_views(self, mappings, ignore_errors=False): for mapping in mappings.values(): if isinstance(mapping, UnionView): PostGISUnionView(self, mapping).create(ignore_errors=ignore_errors) def create_generalized_tables(self, mappings): mappings = [m for m in mappings.values() if isinstance(m, GeneralizedTable)] for mapping in sorted(mappings, key=lambda x: x.name, reverse=True): PostGISGeneralizedTable(self, mapping).create() def postprocess_tables(self, mappings): mappings = [m for m in mappings.values() if isinstance(m, FixInvalidPolygons)] for mapping in mappings: PostGISFixInvalidPolygons(self, mapping).update() def optimize(self, mappings): mappings = [m for m in mappings.values() if isinstance(m, (GeneralizedTable, Mapping))] for mapping in mappings: table_name = self.to_tablename(mapping.name) self.optimize_table(table_name, '%s_geom' % table_name) self.vacuum() def optimize_table(self, table_name, idx_name): cur = self.connection.cursor() print 'Clustering table %s' % table_name cur.execute('CLUSTER "%s" ON "%s"' % (idx_name, table_name)) self.connection.commit() def vacuum(self): old_isolation_level = self.connection.isolation_level self.reconnect() self.connection.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) cur = self.connection.cursor() print 'Vacuum analyze' cur.execute("VACUUM ANALYZE") self.connection.set_isolation_level(old_isolation_level) class PostGISUnionView(object): def __init__(self, db, mapping): self.mapping = mapping self.db = db self.view_name = db.to_tablename(mapping.name) def _view_stmt(self): selects = [] if config.imposm_pg_serial_id: serial_column = "id, " else: serial_column = "" for mapping in self.mapping.mappings: field_str = ', '.join(self._mapping_fields(mapping)) selects.append("""SELECT %s osm_id, geometry, %s, '%s' as class from "%s" """ % ( serial_column, field_str, mapping.classname or mapping.name, self.db.to_tablename(mapping.name))) selects = '\nUNION ALL\n'.join(selects) stmt = 'CREATE VIEW "%s" as (\n%s\n)' % (self.view_name, selects) return stmt def _geom_table_stmt(self): assert self.db.use_geometry_columns_table stmt = "insert into geometry_columns values ('', 'public', '%s', 'geometry', 2, %d, 'GEOMETRY')" % ( self.view_name, self.db.srid) return stmt def _mapping_fields(self, mapping): mapping_fields = set([n for n, t in mapping.fields]) fields = [] for name, default in self.mapping.fields: if name in mapping_fields: fields.append('"' + name + '"') else: if default is None: default = 'null' elif isinstance(default, basestring): default = "'%s'" % default else: default = str(default) fields.append(default + ' as "' + name + '"') return fields def create(self, ignore_errors): cur = self.db.connection.cursor() cur.execute('BEGIN') self.db.drop_table_or_view(cur, self.view_name) with self.db.savepoint(cur, raise_errors=not ignore_errors): cur.execute(self._view_stmt()) if self.db.use_geometry_columns_table: cur.execute('SELECT * FROM geometry_columns WHERE f_table_name = %s', (self.view_name, )) if cur.fetchall(): # drop old entry to handle changes of SRID cur.execute('DELETE FROM geometry_columns WHERE f_table_name = %s', (self.view_name, )) cur.execute(self._geom_table_stmt()) class PostGISGeneralizedTable(object): def __init__(self, db, mapping): self.db = db self.mapping = mapping self.table_name = db.to_tablename(mapping.name) def _geom_table_stmt(self): assert self.db.use_geometry_columns_table stmt = "insert into geometry_columns values ('', 'public', '%s', 'geometry', 2, %d, 'GEOMETRY')" % ( self.table_name, self.db.srid) return stmt def _stmt(self): fields = ', '.join(['"' + n + '"' for n, t in self.mapping.fields]) if fields: fields += ',' where = '' if self.mapping.where: where = ' WHERE %s' % (self.mapping.where) if config.imposm_pg_serial_id: serial_column = "id, " else: serial_column = "" return """CREATE TABLE "%s" AS (SELECT %s osm_id, %s ST_SimplifyPreserveTopology(geometry, %f) as geometry from "%s"%s)""" % ( self.table_name, serial_column, fields, self.mapping.tolerance, self.db.to_tablename(self.mapping.origin.name), where) def create(self): cur = self.db.connection.cursor() cur.execute('BEGIN') self.db.drop_table_or_view(cur, self.table_name) cur.execute(self._stmt()) if self.db.use_geometry_columns_table: cur.execute('SELECT * FROM geometry_columns WHERE f_table_name = %s', (self.table_name, )) if cur.fetchall(): # drop old entry to handle changes of SRID cur.execute('DELETE FROM geometry_columns WHERE f_table_name = %s', (self.table_name, )) cur.execute(self._geom_table_stmt()) class PostGISFixInvalidPolygons(object): """ Try to make all polygons valid. ST_SimplifyPreserveTopology (used for the generalized tables) can return invalid geometries but ST_Buffer should be able to fix them. """ def __init__(self, db, mapping): self.db = db self.mapping = mapping self.table_name = db.to_tablename(mapping.name) def _fetch_invalid_geometries(self): select_invalid = 'SELECT osm_id FROM %s WHERE ST_IsValid(geometry)=False' %(self.table_name,) cur = self.db.connection.cursor() cur.execute(select_invalid) for row in cur: yield row[0] def update(self): if self.mapping.geom_type != 'GEOMETRY': log.info('Validating of polygons only usable for Polygon/GEOMETRY mappings') return cur = self.db.connection.cursor() # fix geometries one-by-one because ST_buffer can fail an we wouldn't be able to # tell wich geometry caused it to fail for osm_id in self._fetch_invalid_geometries(): update = 'UPDATE %s SET geometry = ST_Buffer(geometry,0) WHERE osm_id = %d' % (self.table_name, osm_id) cur.execute('SAVEPOINT polygonfix;') try: cur.execute(update) except psycopg2.DatabaseError, ex: log.warn('Could not fix geometry with osm_id %d. Row will be deleted. Internal error was: %s' % (osm_id, ex)) cur.execute('ROLLBACK TO SAVEPOINT polygonfix;') cur.execute('DELETE FROM %s WHERE osm_id = %d' % (self.table_name, osm_id)) else: cur.execute('RELEASE SAVEPOINT polygonfix;') class TrigramIndex(object): pass class StringIndex(object): pass class Index(object): pass imposm-2.6.0/imposm/dbimporter.py0000644000076500000240000002431512454213016016774 0ustar oltstaff00000000000000# Copyright 2011, 2012 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from collections import defaultdict from multiprocessing import Process import threading from Queue import Queue from imposm.base import OSMElem from imposm.geom import IncompletePolygonError from imposm.mapping import DropElem, PolygonTable from imposm.multipolygon import RelationBuilder from imposm.util import setproctitle import logging log = logging.getLogger(__name__) class ImporterProcess(Process): name = 'importer' def __init__(self, in_queue, db, mapper, osm_cache, dry_run): Process.__init__(self) self.daemon = True setproctitle('imposm %s process' % self.name) self.in_queue = in_queue self.mapper = mapper self.osm_cache = osm_cache self.db = db self.dry_run = dry_run self.db_queue = Queue(256) def run(self): self.setup() # cProfile.runctx('self.doit()', globals(), locals(), 'profile%s.dat' % (self.name,)) self.doit() self.teardown() def setup(self): self.db_importer = threading.Thread(target=self.db_importer, args=(self.db_queue, self.db), kwargs=dict(dry_run=self.dry_run)) self.db_importer.start() def doit(self): pass def teardown(self): self.osm_cache.close_all() self.db_queue.put(None) self.db_importer.join() class TupleBasedImporter(ImporterProcess): def db_importer(self, queue, db, dry_run=False): db.reconnect() mappings = defaultdict(list) while True: data = queue.get() if data is None: break mapping, osm_id, osm_elem, extra_args = data insert_data = mappings[mapping] if isinstance(osm_elem.geom, (list)): for geom in osm_elem.geom: insert_data.append((osm_id, db.geom_wrapper(geom)) + tuple(extra_args)) else: insert_data.append((osm_id, db.geom_wrapper(osm_elem.geom)) + tuple(extra_args)) if len(insert_data) >= 128: if not dry_run: db.insert(mapping, insert_data) del mappings[mapping] # flush for mapping, insert_data in mappings.iteritems(): if not dry_run: db.insert(mapping, insert_data) def insert(self, mappings, osm_id, geom, tags): inserted = False for type, ms in mappings: for m in ms: osm_elem = OSMElem(osm_id, geom, type, tags) try: m.filter(osm_elem) m.build_geom(osm_elem) extra_args = m.field_values(osm_elem) self.db_queue.put((m, osm_id, osm_elem, extra_args)) inserted = True except DropElem: pass return inserted class DictBasedImporter(ImporterProcess): def db_importer(self, queue, db, dry_run=False): db.reconnect() insert_data = [] while True: data = queue.get() if data is None: break data['geometry'] = db.geom_wrapper(data['geometry']) insert_data.append(data) if len(insert_data) >= 128: if not dry_run: db.insert(insert_data) insert_data = [] # flush if not dry_run: db.insert(insert_data) def insert(self, mappings, osm_id, geom, tags): inserted = False osm_objects = {} for type, ms in mappings: for m in ms: osm_elem = OSMElem(osm_id, geom, type, tags) try: m.filter(osm_elem) except DropElem: continue if m.geom_type in osm_objects: obj = osm_objects[m.geom_type] obj['fields'].update(m.field_dict(osm_elem)) obj['fields'][type[0]] = type[1] obj['mapping_names'].append(m.name) else: try: m.build_geom(osm_elem) except DropElem: continue obj = {} obj['fields'] = m.field_dict(osm_elem) obj['fields'][type[0]] = type[1] obj['osm_id'] = osm_id obj['geometry'] = osm_elem.geom obj['mapping_names'] = [m.name] osm_objects[m.geom_type] = obj inserted = True for obj in osm_objects.itervalues(): if isinstance(obj['geometry'], (list, )): for geom in obj['geometry']: obj_part = obj.copy() obj_part['geometry'] = geom self.db_queue.put(obj_part) else: self.db_queue.put(obj) return inserted class NodeProcess(ImporterProcess): name = 'node' def doit(self): while True: nodes = self.in_queue.get() if nodes is None: break for node in nodes: mappings = self.mapper.for_nodes(node.tags) if not mappings: continue self.insert(mappings, node.osm_id, node.coord, node.tags) class NodeProcessDict(NodeProcess, DictBasedImporter): pass class NodeProcessTuple(NodeProcess, TupleBasedImporter): pass def filter_out_polygon_mappings(mappings): result = [] for tag, ms in mappings: ms = [m for m in ms if m.table != PolygonTable] if ms: result.append((tag, ms)) return result class WayProcess(ImporterProcess): name = 'way' def doit(self): coords_cache = self.osm_cache.coords_cache(mode='r') inserted_ways_cache = self.osm_cache.inserted_ways_cache(mode='r') inserted_ways = iter(inserted_ways_cache) try: skip_id = inserted_ways.next() except StopIteration: skip_id = 2**64 while True: ways = self.in_queue.get() if ways is None: break for way in ways: # forward to the next skip id that is not smaller # than our current id while skip_id < way.osm_id: try: skip_id = inserted_ways.next() except StopIteration: skip_id = 2**64 mappings = self.mapper.for_ways(way.tags) if not mappings: continue if skip_id == way.osm_id: # skip polygon mappings, way was already inserted as MultiPolygon mappings = filter_out_polygon_mappings(mappings) if not mappings: continue coords = coords_cache.get_coords(way.refs) if not coords: log.debug('missing coords for way %s', way.osm_id) continue self.insert(mappings, way.osm_id, coords, way.tags) class WayProcessDict(WayProcess, DictBasedImporter): pass class WayProcessTuple(WayProcess, TupleBasedImporter): pass class RelationProcess(ImporterProcess): name = 'relation' def __init__(self, in_queue, db, mapper, osm_cache, dry_run, inserted_way_queue): super(RelationProcess, self).__init__(in_queue, db, mapper, osm_cache, dry_run) self.inserted_way_queue = inserted_way_queue def doit(self): coords_cache = self.osm_cache.coords_cache(mode='r') ways_cache = self.osm_cache.ways_cache(mode='r') while True: relations = self.in_queue.get() if relations is None: break for relation in relations: builder = RelationBuilder(relation, ways_cache, coords_cache) try: builder.build() except IncompletePolygonError, ex: if str(ex): log.debug(ex) continue mappings = self.mapper.for_relations(relation.tags) inserted = False if mappings: inserted = self.insert(mappings, relation.osm_id, relation.geom, relation.tags) if inserted and any(m.skip_inserted_ways for _, ms in mappings for m in ms): for w in relation.ways: if mappings_intersect(mappings, self.mapper.for_relations(w.tags)): self.inserted_way_queue.put(w.osm_id) def mappings_intersect(a, b): """ True if `a` and `b` share a mapping. Mapping is a list of ((key, value), (mapping1, mapping2,...)). >>> mappings_intersect([(('waterway', 'riverbank'), ('mapping_waterareas',))], ... [(('waterway', 'riverbank'), ('mapping_waterareas',))]) True >>> mappings_intersect([(('waterway', 'riverbank'), ('mapping_waterareas',))], ... [(('place', 'island'), ('mapping_landusage',))]) False >>> mappings_intersect([(('waterway', 'riverbank'), ('mapping_waterareas',))], ... [(('place', 'island'), ('mapping_landusage',)), ... (('waterway', 'riverbank'), ('mapping_waterareas',))]) True """ for a_key_val, a_mappings in a: for a_map in a_mappings: for b_key_val, b_mappings in b: for b_map in b_mappings: if a_key_val == b_key_val and a_map == b_map: return True return False class RelationProcessDict(RelationProcess, DictBasedImporter): pass class RelationProcessTuple(RelationProcess, TupleBasedImporter): pass imposm-2.6.0/imposm/defaultmapping.py0000644000076500000240000002502312236167777017646 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from imposm.mapping import ( Options, Points, LineStrings, Polygons, String, Bool, Integer, OneOfInt, set_default_name_type, LocalizedName, WayZOrder, ZOrder, Direction, GeneralizedTable, UnionView, FixInvalidPolygons, PseudoArea, meter_to_mapunit, sqr_meter_to_mapunit, ) # # internal configuration options # # uncomment to make changes to the default values # import imposm.config # # # import relations with missing rings # imposm.config.import_partial_relations = False # # # select relation builder: union or contains # imposm.config.relation_builder = 'contains' # # # log relation that take longer than x seconds # imposm.config.imposm_multipolygon_report = 60 # # # skip relations with more rings (0 skip nothing) # imposm.config.imposm_multipolygon_max_ring = 0 # # # split ways that are longer than x nodes (0 to split nothing) # imposm.config.imposm_linestring_max_length = 50 # # # cache coords in a compact storage (with delta encoding) # # use this when memory is limited (default) # imposm.config.imposm_compact_coords_cache = True # set_default_name_type(LocalizedName(['name:en', 'int_name', 'name'])) db_conf = Options( # db='osm', host='localhost', port=5432, user='osm', password='osm', sslmode='allow', prefix='osm_new_', proj='epsg:900913', ) class Highway(LineStrings): fields = ( ('tunnel', Bool()), ('bridge', Bool()), ('oneway', Direction()), ('ref', String()), ('z_order', WayZOrder()), ) field_filter = ( ('area', Bool()), ) places = Points( name = 'places', mapping = { 'place': ( 'country', 'state', 'region', 'county', 'city', 'town', 'village', 'hamlet', 'suburb', 'locality', ), }, fields = ( ('z_order', ZOrder([ 'country', 'state', 'region', 'county', 'city', 'town', 'village', 'hamlet', 'suburb', 'locality', ])), ('population', Integer()), ), ) admin = Polygons( name = 'admin', mapping = { 'boundary': ( 'administrative', ), }, fields = ( ('admin_level', OneOfInt('1 2 3 4 5 6'.split())), ), ) motorways = Highway( name = 'motorways', mapping = { 'highway': ( 'motorway', 'motorway_link', 'trunk', 'trunk_link', ), } ) mainroads = Highway( name = 'mainroads', mapping = { 'highway': ( 'primary', 'primary_link', 'secondary', 'secondary_link', 'tertiary', )} ) buildings = Polygons( name = 'buildings', mapping = { 'building': ( '__any__', )} ) minorroads = Highway( name = 'minorroads', mapping = { 'highway': ( 'road', 'path', 'track', 'service', 'footway', 'bridleway', 'cycleway', 'steps', 'pedestrian', 'living_street', 'unclassified', 'residential', )} ) transport_points = Points( name = 'transport_points', fields = ( ('ref', String()), ), mapping = { 'highway': ( 'motorway_junction', 'turning_circle', 'bus_stop', ), 'railway': ( 'station', 'halt', 'tram_stop', 'crossing', 'level_crossing', 'subway_entrance', ), 'aeroway': ( 'aerodome', 'terminal', 'helipad', 'gate', )} ) railways = LineStrings( name = 'railways', fields = ( ('tunnel', Bool()), ('bridge', Bool()), # ('ref', String()), ('z_order', WayZOrder()), ), mapping = { 'railway': ( 'rail', 'tram', 'light_rail', 'subway', 'narrow_gauge', 'preserved', 'funicular', 'monorail', )} ) waterways = LineStrings( name = 'waterways', mapping = { 'waterway': ( 'stream', 'river', 'canal', 'drain', )}, field_filter = ( ('tunnel', Bool()), ), ) waterareas = Polygons( name = 'waterareas', mapping = { 'waterway': ('riverbank',), 'natural': ('water',), 'landuse': ('basin', 'reservoir'), }) aeroways = LineStrings( name = 'aeroways', mapping = { 'aeroway': ( 'runway', 'taxiway', )} ) transport_areas = Polygons( name = 'transport_areas', mapping = { 'railway': ( 'station', ), 'aeroway': ( 'aerodrome', 'terminal', 'helipad', 'apron', ), }) landusages = Polygons( name = 'landusages', fields = ( ('area', PseudoArea()), ('z_order', ZOrder([ 'pedestrian', 'footway', 'playground', 'park', 'forest', 'cemetery', 'farmyard', 'farm', 'farmland', 'wood', 'meadow', 'grass', 'village_green', 'recreation_ground', 'garden', 'sports_centre', 'pitch', 'common', 'allotments', 'golf_course', 'university', 'school', 'college', 'library', 'fuel', 'parking', 'nature_reserve', 'cinema', 'theatre', 'place_of_worship', 'hospital', 'scrub', 'quarry', 'residential', 'retail', 'commercial', 'industrial', 'railway', 'land', ])), ), mapping = { 'landuse': ( 'park', 'forest', 'residential', 'retail', 'commercial', 'industrial', 'railway', 'cemetery', 'grass', 'farmyard', 'farm', 'farmland', 'wood', 'meadow', 'village_green', 'recreation_ground', 'allotments', 'quarry', ), 'leisure': ( 'park', 'garden', 'playground', 'golf_course', 'sports_centre', 'pitch', 'stadium', 'common', 'nature_reserve', ), 'natural': ( 'wood', 'land', 'scrub', ), 'highway': ( 'pedestrian', 'footway', ), 'amenity': ( 'university', 'school', 'college', 'library', 'fuel', 'parking', 'cinema', 'theatre', 'place_of_worship', 'hospital', ), }) amenities = Points( name='amenities', mapping = { 'amenity': ( 'university', 'school', 'library', 'fuel', 'hospital', 'fire_station', 'police', 'townhall', ), }) motorways_gen1 = GeneralizedTable( name = 'motorways_gen1', tolerance = meter_to_mapunit(50.0), origin = motorways, ) mainroads_gen1 = GeneralizedTable( name = 'mainroads_gen1', tolerance = meter_to_mapunit(50.0), origin = mainroads, ) railways_gen1 = GeneralizedTable( name = 'railways_gen1', tolerance = meter_to_mapunit(50.0), origin = railways, ) motorways_gen0 = GeneralizedTable( name = 'motorways_gen0', tolerance = meter_to_mapunit(200.0), origin = motorways_gen1, ) mainroads_gen0 = GeneralizedTable( name = 'mainroads_gen0', tolerance = meter_to_mapunit(200.0), origin = mainroads_gen1, ) railways_gen0 = GeneralizedTable( name = 'railways_gen0', tolerance = meter_to_mapunit(200.0), origin = railways_gen1, ) landusages_gen0 = GeneralizedTable( name = 'landusages_gen0', tolerance = meter_to_mapunit(200.0), origin = landusages, where = "ST_Area(geometry)>%f" % sqr_meter_to_mapunit(500000), ) landusages_gen1 = GeneralizedTable( name = 'landusages_gen1', tolerance = meter_to_mapunit(50.0), origin = landusages, where = "ST_Area(geometry)>%f" % sqr_meter_to_mapunit(50000), ) waterareas_gen0 = GeneralizedTable( name = 'waterareas_gen0', tolerance = meter_to_mapunit(200.0), origin = waterareas, where = "ST_Area(geometry)>%f" % sqr_meter_to_mapunit(500000), ) waterareas_gen1 = GeneralizedTable( name = 'waterareas_gen1', tolerance = meter_to_mapunit(50.0), origin = waterareas, where = "ST_Area(geometry)>%f" % sqr_meter_to_mapunit(50000), ) roads = UnionView( name = 'roads', fields = ( ('bridge', 0), ('ref', None), ('tunnel', 0), ('oneway', 0), ('z_order', 0), ), mappings = [motorways, mainroads, minorroads, railways], ) roads_gen1 = UnionView( name = 'roads_gen1', fields = ( ('bridge', 0), ('ref', None), ('tunnel', 0), ('oneway', 0), ('z_order', 0), ), mappings = [railways_gen1, mainroads_gen1, motorways_gen1], ) roads_gen0 = UnionView( name = 'roads_gen0', fields = ( ('bridge', 0), ('ref', None), ('tunnel', 0), ('oneway', 0), ('z_order', 0), ), mappings = [railways_gen0, mainroads_gen0, motorways_gen0], ) landuse_gen1_valid = FixInvalidPolygons( origin = landusages_gen1, ) landuse_gen0_valid = FixInvalidPolygons( origin = landusages_gen0, ) imposm-2.6.0/imposm/geom.py0000644000076500000240000003530712454213016015557 0ustar oltstaff00000000000000# Copyright 2011, 2012 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import division import math import codecs import os import shapely.geometry import shapely.geos import shapely.prepared from shapely.geometry.base import BaseGeometry from shapely import geometry from shapely import wkt from shapely.ops import cascaded_union, linemerge from shapely.topology import TopologicalError try: import rtree except ImportError: rtree = None from imposm import config from imposm.util.geom import load_polygons, load_datasource, build_multipolygon import logging log = logging.getLogger(__name__) class InvalidGeometryError(Exception): pass class IncompletePolygonError(Exception): pass TOLERANCE_DEEGREES = 1e-8 TOLERANCE_METERS = 1e-3 # older versions had unhandled floating point execptions in .buffer(0) SHAPELY_SUPPORTS_BUFFER = shapely.geos.geos_capi_version >= (1, 6, 0) def validate_and_simplify(geom, meter_units=False): if SHAPELY_SUPPORTS_BUFFER: try: # buffer(0) is nearly fast as is_valid return geom.buffer(0) except ValueError: # shapely raises ValueError if buffer(0) result is empty raise InvalidGeometryError('geometry is empty') orig_geom = geom if not geom.is_valid: tolerance = TOLERANCE_METERS if meter_units else TOLERANCE_DEEGREES try: geom = geom.simplify(tolerance, False) except ValueError: # shapely raises ValueError if buffer(0) result is empty raise InvalidGeometryError('geometry is empty') if not geom.is_valid: raise InvalidGeometryError('geometry is invalid, could not simplify: %s' % orig_geom) return geom class GeomBuilder(object): def build(self, osm_elem): # TODO is this method still in use? try: if isinstance(osm_elem.coords, BaseGeometry): return osm_elem.coords geom_wkt = self.to_wkt(osm_elem.coords) if geom_wkt is not None: geom = wkt.loads(geom_wkt) except Exception, ex: raise InvalidGeometryError('unable to build geometry %s: %s %s' % (osm_elem.osm_id, ex, osm_elem.coords)) if geom_wkt is None or geom is None: # unable to build valid wkt (non closed polygon, etc) raise InvalidGeometryError() return geom def check_geom_type(self, geom): return def build_geom(self, osm_elem): try: if isinstance(osm_elem.coords, BaseGeometry): if osm_elem.coords.is_empty: raise InvalidGeometryError('empty geometry') self.check_geom_type(osm_elem.coords) return osm_elem.coords geom = self.to_geom(osm_elem.coords) except InvalidGeometryError, ex: raise InvalidGeometryError('unable to build geometry %s: %s %s' % (osm_elem.osm_id, ex, osm_elem.coords)) if geom is None: # unable to build valid wkt (non closed polygon, etc) raise InvalidGeometryError() return geom class PointBuilder(GeomBuilder): def to_wkt(self, data): if len(data) != 2: return None return 'POINT(%f %f)' % data def to_geom(self, data): if len(data) != 2: return None return geometry.Point(*data) def check_geom_type(self, geom): if geom.type != 'Point': raise InvalidGeometryError('expected Point, got %s' % geom.type) def build_checked_geom(self, osm_elem, validate=False): geom = self.build_geom(osm_elem) if not validate or geom.is_valid: return geom else: raise InvalidGeometryError('invalid geometry for %s: %s, %s' % (osm_elem.osm_id, geom, osm_elem.coords)) class PolygonBuilder(GeomBuilder): def to_wkt(self, data): if len(data) >= 4 and data[0] == data[-1]: return 'POLYGON((' + ', '.join('%f %f' % p for p in data) + '))' return None def to_geom(self, data): if len(data) >= 4 and data[0] == data[-1]: return geometry.Polygon(data) return None def check_geom_type(self, geom): if geom.type not in ('Polygon', 'MultiPolygon'): raise InvalidGeometryError('expected Polygon or MultiPolygon, got %s' % geom.type) def build_checked_geom(self, osm_elem, validate=False): geom = self.build_geom(osm_elem) if not validate: return geom try: return validate_and_simplify(geom) except InvalidGeometryError: raise InvalidGeometryError('invalid geometry for %s: %s, %s' % (osm_elem.osm_id, geom, osm_elem.coords)) class LineStringBuilder(GeomBuilder): def to_wkt(self, data): if len(data) <= 1: return None if len(data) == 2 and data[0] == data[1]: return None return 'LINESTRING(' + ', '.join('%f %f' % p for p in data) + ')' def check_geom_type(self, geom): if geom.type != 'LineString': raise InvalidGeometryError('expected LineString, got %s' % geom.type) def to_geom(self, data, max_length=None): if len(data) <= 1: return None if len(data) == 2 and data[0] == data[1]: return None if max_length is None: max_length = config.imposm_linestring_max_length if max_length and len(data) > max_length: chunks = math.ceil(len(data) / max_length) length = int(len(data) // chunks) lines = [] for i in xrange(1, len(data), length): lines.append(geometry.LineString(data[i-1:i+length])) return lines return geometry.LineString(data) def build_checked_geom(self, osm_elem, validate=False): geom = self.build_geom(osm_elem) if not validate or geom.is_valid: return geom else: raise InvalidGeometryError('invalid geometry for %s: %s, %s' % (osm_elem.osm_id, geom, osm_elem.coords)) def tile_bbox(bbox, grid_width): """ Tile bbox into multiple sub-boxes, each of `grid_width` size. >>> list(tile_bbox((-1, 1, 0.49, 1.51), 0.5)) #doctest: +NORMALIZE_WHITESPACE [(-1.0, 1.0, -0.5, 1.5), (-1.0, 1.5, -0.5, 2.0), (-0.5, 1.0, 0.0, 1.5), (-0.5, 1.5, 0.0, 2.0), (0.0, 1.0, 0.5, 1.5), (0.0, 1.5, 0.5, 2.0)] """ min_x = math.floor(bbox[0]/grid_width) * grid_width min_y = math.floor(bbox[1]/grid_width) * grid_width max_x = math.ceil(bbox[2]/grid_width) * grid_width max_y = math.ceil(bbox[3]/grid_width) * grid_width x_steps = math.ceil((max_x - min_x) / grid_width) y_steps = math.ceil((max_y - min_y) / grid_width) for x in xrange(int(x_steps)): for y in xrange(int(y_steps)): yield ( min_x + x * grid_width, min_y + y * grid_width, min_x + (x + 1) * grid_width, min_y + (y + 1)* grid_width, ) def split_polygon_at_grid(geom, grid_width=0.1, current_grid_width=10.0): """ >>> p = list(split_polygon_at_grid(geometry.box(-0.5, 1, 0.2, 2), 1)) >>> p[0].contains(geometry.box(-0.5, 1, 0, 2)) True >>> p[0].area == geometry.box(-0.5, 1, 0, 2).area True >>> p[1].contains(geometry.box(0, 1, 0.2, 2)) True >>> p[1].area == geometry.box(0, 1, 0.2, 2).area True """ if not geom.is_valid: geom = geom.buffer(0) for i, split_box in enumerate(tile_bbox(geom.bounds, current_grid_width)): try: polygon_part = geom.intersection(shapely.geometry.box(*split_box)) except TopologicalError: continue if not polygon_part.is_empty and polygon_part.type.endswith('Polygon'): if grid_width >= current_grid_width: yield polygon_part else: for part in split_polygon_at_grid(polygon_part, grid_width, current_grid_width/10.0): yield part def load_geom(source): geom = load_datasource(source) if geom: # get the first and maybe only geometry if not check_wgs84_srs(geom[0]): log.error('Geometry is not in EPSG:4326') return None if rtree: return LimitRTreeGeometry(geom) else: log.info('You should install RTree for large --limit-to polygons') return LimitPolygonGeometry(build_multipolygon(geom)[1]) return None def check_wgs84_srs(geom): bbox = geom.bounds if bbox[0] >= -180 and bbox[1] >= -90 and bbox[2] <= 180 and bbox[3] <= 90: return True return False class EmtpyGeometryError(Exception): pass class LimitPolygonGeometry(object): def __init__(self, shapely_geom): self._geom = shapely_geom self._prepared_geom = None self._prepared_counter = 0 self._prepared_max = 100000 @property def geom(self): # GEOS internal data structure for prepared geometries grows over time, # recreate to limit memory consumption if not self._prepared_geom or self._prepared_counter > self._prepared_max: self._prepared_geom = shapely.prepared.prep(self._geom) self._prepared_counter = 0 self._prepared_counter += 1 return self._prepared_geom def intersection(self, geom): if self.geom.contains_properly(geom): # no need to limit contained geometries return geom new_geom = None if self.geom.intersects(geom): try: # can not use intersection with prepared geom new_geom = self._geom.intersection(geom) except TopologicalError: pass if not new_geom or new_geom.is_empty: raise EmtpyGeometryError('No intersection or empty geometry') new_geom = filter_geometry_by_type(new_geom, geom.type) if new_geom: return new_geom raise EmtpyGeometryError('No intersection or empty geometry') def filter_geometry_by_type(geometry, geom_type): """ Filter (multi)geometry for compatible `geom_type`, because we can't insert points into linestring tables for example """ if geometry.type == geom_type: # same type is fine return geometry if geometry.type == 'Polygon' and geom_type == 'MultiPolygon': # multipolygon mappings also support polygons return geometry if geometry.type == 'MultiPolygon' and geom_type == 'Polygon': # polygon mappings should also support multipolygons return geometry if hasattr(geometry, 'geoms'): # GeometryCollection or MultiLineString? return list of geometries geoms = [] for part in geometry.geoms: # only parts with same type if part.type == geom_type: geoms.append(part) if geoms: return geoms return None def flatten_polygons(polygons): for polygon in polygons: if polygon.type == 'MultiPolygon': for p in polygon.geoms: yield p else: yield polygon def flatten_linestrings(linestrings): for linestring in linestrings: if linestring.type == 'MultiLineString': for ls in linestring.geoms: yield ls else: yield linestring def filter_invalid_linestrings(linestrings): for linestring in linestrings: # filter out tiny linestrings, can become invalid geometries in postgis if linestring.length > 1e-9: yield linestring class LimitRTreeGeometry(object): def __init__(self, polygons): index = rtree.index.Index() sub_polygons = [] part_idx = 0 for polygon in polygons: for part in split_polygon_at_grid(polygon): sub_polygons.append(part) index.insert(part_idx, part.bounds) part_idx += 1 self.polygons = sub_polygons self.index = index def intersection(self, geom): intersection_ids = list(self.index.intersection(geom.bounds)) if not intersection_ids: raise EmtpyGeometryError('No intersection or empty geometry') intersections = [] for i in intersection_ids: polygon = self.polygons[i] if polygon.contains(geom): return geom if polygon.intersects(geom): try: new_geom_part = polygon.intersection(geom) new_geom_part = filter_geometry_by_type(new_geom_part, geom.type) if new_geom_part: if isinstance(new_geom_part, list): intersections.extend(new_geom_part) else: intersections.append(new_geom_part) except TopologicalError: pass if not intersections: raise EmtpyGeometryError('No intersection or empty geometry') # intersections from multiple sub-polygons # try to merge them back to a single geometry try: if geom.type.endswith('Polygon'): union = cascaded_union(list(flatten_polygons(intersections))) elif geom.type.endswith('LineString'): linestrings = flatten_linestrings(intersections) linestrings = list(filter_invalid_linestrings(linestrings)) if not linestrings: raise EmtpyGeometryError() union = linemerge(linestrings) if union.type == 'MultiLineString': union = list(union.geoms) elif geom.type == 'Point': union = intersections[0] else: log.warn('unexpexted geometry type %s', geom.type) raise EmtpyGeometryError() except ValueError, ex: # likely an 'No Shapely geometry can be created from null value' error log.warn('could not create union: %s', ex) raise EmtpyGeometryError() return union imposm-2.6.0/imposm/mapping.py0000644000076500000240000005360012454213016016257 0ustar oltstaff00000000000000# -:- encoding: UTF8 -:- # Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import division import math import imposm.geom ANY = '__any__' __all__ = [ 'LineStrings', 'Polygons', 'Points', 'Options', 'PolygonTable', 'ZOrder', 'PointTable', 'String', 'LocalizedName', 'LineStringTable', 'Direction', 'OneOfInt', 'Integer', 'WayZOrder', 'Bool', 'GeneralizedTable', 'FixInvalidPolygons', 'UnionView', 'set_default_name_field', ] default_name_field = None def set_default_name_type(type, column_name='name'): """ Set new default type for 'name' field. :: set_default_name_type(LocalizedName(['name:en', 'int_name', 'name'])) """ global default_name_field default_name_field = column_name, type # changed by imposm.app if the projection is epsg:4326 import_srs_is_geographic = False def meter_to_mapunit(meter): """ Convert ``meter`` into the mapunit of the import. Only supports EPSG:4326 (degrees) at the moment, all other SRS will use meter as mapunit. """ if import_srs_is_geographic: deg_to_meter = (40000 * 1000) / 360 return meter / deg_to_meter return meter def sqr_meter_to_mapunit(sqr_meter): """ Convert ``sqr_meter`` into the mapunit of the import. Only supports EPSG:4326 (degrees) at the moment, all other SRS will use meter as mapunit. """ if import_srs_is_geographic: return meter_to_mapunit(math.sqrt(sqr_meter))**2 return sqr_meter class Mapping(object): table = None fields = () field_filter = () classname = None _insert_stmt = None with_type_field = True def __init__(self, name, mapping, fields=None, field_filter=None, with_type_field=None): self.name = name self.mapping = mapping self.fields = fields or tuple(self.fields) self.limit_to_polygon = None if with_type_field is not None: # allow subclass to define other default by setting it as class variable self.with_type_field = with_type_field self._add_type_field() self._add_name_field() if field_filter: self.field_filter = field_filter def _add_name_field(self): """ Add name field to default if not set. """ if not any(1 for name, _type in self.fields if name == 'name'): if default_name_field: self.fields = (default_name_field,) + self.fields else: self.fields = (('name', Name()),) + self.fields def _add_type_field(self): """ Add type field. """ if not self.with_type_field: return for name, type_ in self.fields: if name == 'type': # do not add type field if already present return self.fields = (('type', Type()), ) + self.fields @property def insert_stmt(self): if not self._insert_stmt: self._insert_stmt = self.table('osm_' + self.name, self).insert_stmt return self._insert_stmt def extra_field_names(self): extra_field_names = [] for field_name, field_filter in self.field_filter: extra_field_names.append(field_name) for field_name, field in self.fields: field_names = field.extra_fields() if field_names is not None: extra_field_names.extend(field_names) else: extra_field_names.append(field_name) return extra_field_names def build_geom(self, osm_elem): try: geom = self.geom_builder.build_checked_geom(osm_elem) if self.limit_to_polygon is not None: geom = self.limit_to_polygon.intersection(geom) osm_elem.geom = geom except imposm.geom.InvalidGeometryError, ex: raise DropElem('invalid geometry: %s' % (ex, )) except imposm.geom.EmtpyGeometryError, ex: raise DropElem(ex) def field_values(self, osm_elem): return [t.value(osm_elem.tags.get(n), osm_elem) for n, t in self.fields] def field_dict(self, osm_elem): result = dict((n, t.value(osm_elem.tags.get(n), osm_elem)) for n, t in self.fields) if self.with_type_field: del result['type'] result[osm_elem.cls] = osm_elem.type return result def filter(self, osm_elem): [t.filter(osm_elem.tags.get(n), osm_elem) for n, t in self.field_filter] def __repr__(self): return '' % self.name class TagMapper(object): def __init__(self, mappings, limit_to=None): self.mappings = mappings self.limit_to_polygon = limit_to self._init_map() def _init_map(self): self.point_mappings = {} self.line_mappings = {} self.polygon_mappings = {} self.point_tags = {} self.line_tags = {} self.polygon_tags = {} for mapping in self.mappings: if mapping.table is PointTable: tags = self.point_tags add_to = self.point_mappings elif mapping.table is LineStringTable: tags = self.line_tags add_to = self.line_mappings elif mapping.table is PolygonTable: tags = self.polygon_tags add_to = self.polygon_mappings for extra in mapping.extra_field_names(): tags.setdefault(extra, set()).add('__any__') for tag, types in mapping.mapping.iteritems(): add_to.setdefault(tag, {}) for type in types: tags.setdefault(tag, set()).add(type) add_to[tag].setdefault(type, []).append(mapping) # add limit_to polygon to each mapping mapping.limit_to_polygon = self.limit_to_polygon def for_nodes(self, tags): return self._mapping_for_tags(self.point_mappings, tags) def for_ways(self, tags): return (self._mapping_for_tags(self.line_mappings, tags) + self._mapping_for_tags(self.polygon_mappings, tags)) def for_relations(self, tags): return self._mapping_for_tags(self.polygon_mappings, tags) def _tag_filter(self, filter_tags): def filter(tags): for k in tags.keys(): if k not in filter_tags: del tags[k] else: if '__any__' in filter_tags[k]: pass elif tags[k] in filter_tags[k]: pass else: del tags[k] if 'name' in tags and len(tags) == 1: del tags['name'] return filter def tag_filter_for_nodes(self): tags = dict(self.point_tags) return self._tag_filter(tags) def tag_filter_for_ways(self): tags = dict() for k, v in self.line_tags.iteritems(): tags.setdefault(k, set()).update(v) for k, v in self.polygon_tags.iteritems(): tags.setdefault(k, set()).update(v) return self._tag_filter(tags) def tag_filter_for_relations(self): tags = dict() for k, v in self.line_tags.iteritems(): tags.setdefault(k, set()).update(v) for k, v in self.polygon_tags.iteritems(): tags.setdefault(k, set()).update(v) tags['type'] = set(['multipolygon', 'boundary', 'land_area']) # for type=multipolygon expected_tags = set(['type', 'name']) _rel_filter = self._tag_filter(tags) def rel_filter(tags): # we only support mulipolygon relations, skip all other # a lot of the admin boundary/land_area relations are not type=multipolygon if tags.get('type') not in ('multipolygon', 'boundary', 'land_area'): tags.clear() return if tags['type'] == 'boundary' and 'boundary' not in tags: # a lot of the boundary relations are not multipolygon # only import with boundary tags (e.g. boundary=administrative) tags.clear() return tag_count = len(tags) _rel_filter(tags) if len(tags) < tag_count: # we removed tags... if not set(tags).difference(expected_tags): # but no tags except name and type are left # remove all, otherwise tags from longest # way/ring would be used during MP building tags.clear() return rel_filter def _mapping_for_tags(self, tag_map, tags): result = [] mapping_set = set() for tag_name in tags: if tag_name in tag_map: tag_value = tags[tag_name] mappings = [] if tag_value in tag_map[tag_name]: mappings.extend(tag_map[tag_name][tag_value]) if ANY in tag_map[tag_name]: mappings.extend(tag_map[tag_name][ANY]) new_mappings = [] for proc in mappings: if proc not in mapping_set: mapping_set.add(proc) new_mappings.append(proc) if new_mappings: result.append(((tag_name, tag_value), tuple(new_mappings))) return result # marker classes class PointTable(object): pass class LineStringTable(object): pass class PolygonTable(object): pass class Points(Mapping): """ Table class for point features. :PostGIS datatype: POINT """ table = PointTable geom_builder = imposm.geom.PointBuilder() geom_type = 'POINT' class LineStrings(Mapping): """ Table class for line string features. :PostGIS datatype: LINESTRING """ table = LineStringTable geom_builder = imposm.geom.LineStringBuilder() geom_type = 'LINESTRING' class Polygons(Mapping): """ Table class for polygon features. :PostGIS datatype: GEOMETRY (POLYGON does not support multi-polygons) """ table = PolygonTable geom_builder = imposm.geom.PolygonBuilder() geom_type = 'GEOMETRY' # for multipolygon support """ Prevent ways that are part of a multi-polygon to be inserted twice. E.g. multipolygon of two closed forests ways where the ways are also tagged would be inserted twice when skip_inserted_ways is False First as a multipolygon when processing the relations and second as a two polygons when processing the ways. """ skip_inserted_ways = True class BoundaryPolygons(Polygons): """ Table class for boundary polygon features. Similar to `Polygons` but ways that are inserted during multi-polygon processing are processed again for ways. :PostGIS datatype: GEOMETRY (POLYGON does not support multi-polygons) """ skip_inserted_ways = False class GeneralizedTable(object): def __init__(self, name, tolerance, origin, where=None): self.name = name self.tolerance = tolerance self.origin = origin self.geom_type = origin.geom_type self.classname = origin.name self.fields = self.origin.fields self.with_type_field = self.origin.with_type_field self.where = where class FixInvalidPolygons(object): """ Post-processing that tries to fix all invalid polygons. :PostGIS datatype: GEOMETRY (POLYGON does not support multi-polygons) """ def __init__(self, origin): self.origin = origin self.name = origin.name self.geom_type = getattr(origin, 'geom_type', None) class UnionView(object): def __init__(self, name, mappings, fields): self.name = name self.mappings = mappings self.fields = fields self._add_name_field() self._add_type_field() def _add_name_field(self): """ Add name field to default if not set. """ if not any(1 for name, _type in self.fields if name == 'name'): if default_name_field: self.fields = ((default_name_field[0], ''),) + self.fields else: self.fields = (('name', ''),) + self.fields def _add_type_field(self): """ Add type field if not configured and at least one mapping has a type field. """ if 'type' not in self.fields and any(m.with_type_field for m in self.mappings): self.fields += (('type', None), ) class DropElem(Exception): pass class FieldType(object): def extra_fields(self): """ List with names of fields (keys) that should be processed during read-phase. Return ``None`` to use the field name from the mapping. Return ``[]`` if no extra fields (keys) are required. """ return None def value(self, val, osm_elem): return val class Type(FieldType): """ Field for type values (i.e. the *value* of the mapped key/value). Use this in combination with ``with_type_field=False`` of the mapping class, if you want to store the value of the mapped key/value in a different column. For example, to get a column ``road_class`` instead of ``type``:: roads = LineStrings( with_type_field = False, name = 'roads', mapping = { 'highway': ( 'motorway', 'trunk', 'secondary', ), }, fields = ( ('road_class', Type(),), ), ) :PostgreSQL datatype: VARCHAR(255) .. versionadded:: 2.4.0 """ column_type = "VARCHAR(255)" def extra_fields(self): return [] def value(self, val, osm_elem): return osm_elem.type class Class(FieldType): """ Field for class values (i.e. the *key* of the mapped key/value). Use this if you want to store the key that was used for this mapping. For example, the following mapping will create a column ``class`` that will have the value ``landuse`` or ``natural``, depending on the feature. :: landusages = Polygons( name = 'landusages', fields = ( ('class', Class()), ), mapping = { 'landuse': ( 'wood', ), 'natural': ( 'wood', ), } ) :PostgreSQL datatype: VARCHAR(255) .. versionadded:: 2.4.0 """ column_type = "VARCHAR(255)" def extra_fields(self): return [] def value(self, val, osm_elem): return osm_elem.cls class String(FieldType): """ Field for string values. :PostgreSQL datatype: VARCHAR(255) """ column_type = "VARCHAR(255)" class Name(String): """ Field for name values. Filters out common FixMe values. :PostgreSQL datatype: VARCHAR(255) .. versionadded:: 2.3.0 """ filter_out_names = set(( 'fixme', 'fix me', 'fix-me!', '0', 'none', 'n/a', 's/n', 'kein name', 'kein', 'unbenannt', 'unbekannt', 'noch unbekannt', 'noch ohne namen', 'noname', 'unnamed', 'namenlos', 'no_name', 'no name', 'editme', '_edit_me_', )) def value(self, val, osm_elem): if val and val.lower() in self.filter_out_names: osm_elem.name = '' val = '' return val class LocalizedName(Name): """ Field for localized name values. Checks different name keys and uses the first key with a valid value. :param coalesce: list of name keys to check :PostgreSQL datatype: VARCHAR(255) .. versionadded:: 2.3.0 """ def __init__(self, coalesce=['name', 'int_name']): self.coalesce_keys = coalesce def extra_fields(self): return self.coalesce_keys def value(self, val, osm_elem): for key in self.coalesce_keys: val = osm_elem.tags.get(key) if val and val.lower() not in self.filter_out_names: osm_elem.name = val return val else: osm_elem.name = '' return '' class Bool(FieldType): """ Field for boolean values. Converts false, no, 0 to False and true, yes, 1 to True. :PostgreSQL datatype: SMALLINT """ # there was a reason this is not BOOL # something didn't supported it, cascadenik? don't remember column_type = "SMALLINT" aliases = { True: set(['false', 'no', '0', 'undefined']), False: set(['true', 'yes', '1', 'undefined']), } def __init__(self, default=True, neg_aliases=None): self.default = default self.neg_aliases = neg_aliases or self.aliases[default] def value(self, val, osm_elem): if val is None or val.strip().lower() in self.neg_aliases: return 0 # not self.default return 1 # self.default def filter(self, val, osm_elem): if self.value(val, osm_elem): raise DropElem class Direction(FieldType): """ Field type for one-way directions. Converts `yes`, `true` and `1` to ``1`` for one ways in the direction of the way, `-1` to ``-1`` for one ways against the direction of the way and ``0`` for all other values. :PostgreSQL datatype: SMALLINT """ column_type = "SMALLINT" def value(self, value, osm_elem): if value: value = value.strip().lower() if value in ('yes', 'true', '1'): return 1 if value == '-1': return -1 return 0 class PseudoArea(FieldType): """ Field for the (pseudo) area of a polygon in square meters. The value is just an approximation since the geometries are in EPSG:4326 and not in a equal-area projection. The approximation is good for smaller polygons (<1%) and should be precise enough to compare geometries for rendering order (larger below smaller). The area of the geometry is multiplied by the cosine of the mid-latitude to compensate the reduced size towards the poles. :PostgreSQL datatype: REAL .. versionadded:: 2.3.0 """ column_type = "REAL" def value(self, val, osm_elem): area = osm_elem.geom.area if not area: return None extent = osm_elem.geom.bounds mid_lat = extent[1] + (abs(extent[3] - extent[1]) / 2) sqr_deg = area * math.cos(math.radians(mid_lat)) # convert deg^2 to m^2 sqr_m = (math.sqrt(sqr_deg) * (40075160 / 360))**2 return sqr_m def extra_fields(self): return [] class OneOfInt(FieldType): """ Field type for integer values. Converts values to integers, drops element if is not included in ``values``. :PostgreSQL datatype: SMALLINT """ column_type = "SMALLINT" def __init__(self, values): self.values = set(values) def value(self, value, osm_elem): if value in self.values: return int(value) raise DropElem class Integer(FieldType): """ Field type for integer values. Converts values to integers, defaults to ``NULL``. :PostgreSQL datatype: INTEGER """ column_type = "INTEGER" def value(self, value, osm_elem): try: return int(value) except: return None class ZOrder(FieldType): """ Field type for z-ordering based on the feature type. :param types: list of mapped feature types, from highest to lowest ranking :PostgreSQL datatype: SMALLINT """ column_type = "SMALLINT" def __init__(self, types): self.rank = {} for i, t in enumerate(types[::-1]): self.rank[t] = i def extra_fields(self): return [] def value(self, val, osm_elem): return self.rank.get(osm_elem.type, 0) class WayZOrder(FieldType): """ Field type for z-ordered based on highway types. Ordering based on the osm2pgsql z-ordering: From ``roads`` = 3 to ``motorways`` = 9, ``railway`` = 7 and unknown = 0. Ordering changes with ``tunnels`` by -10, ``bridges`` by +10 and ``layer`` by 10 * ``layer``. :PostgreSQL datatype: SMALLINT """ column_type = "SMALLINT" rank = { 'minor': 3, 'road': 3, 'unclassified': 3, 'residential': 3, 'tertiary_link': 3, 'tertiary': 4, 'secondary_link': 3, 'secondary': 5, 'primary_link': 3, 'primary': 6, 'trunk_link': 3, 'trunk': 8, 'motorway_link': 3, 'motorway': 9, } brunnel_bool = Bool() def extra_fields(self): return [] def value(self, val, osm_elem): tags = osm_elem.tags z_order = 0 l = self.layer(tags) z_order += l * 10 r = self.rank.get(osm_elem.type, 0) if not r: r = 7 if 'railway' in tags else 0 z_order += r if self.brunnel_bool.value(tags.get('tunnel'), {}): z_order -= 10 if self.brunnel_bool.value(tags.get('bridge'), {}): z_order += 10 return z_order def layer(self, tags): l = tags.get('layer', 0) try: return int(l) except ValueError: return 0 class Options(dict): def __setattr__(self, name, value): self[name] = value def __getattr__(self, name): try: return self[name] except KeyError: raise AttributeError('%s not in %r' % (name, self)) imposm-2.6.0/imposm/merge.py0000644000076500000240000000551711766043214015735 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import difflib def merge(a, b): sqm = difflib.SequenceMatcher(None, a, b) matching_blocks = sqm.get_matching_blocks() matching_blocks.pop(-1) if not matching_blocks: return None a_idx = b_idx = 0 result = [] for block in matching_blocks: if a_idx < block[0]: result.extend(a[a_idx:block[0]]) if b_idx < block[1]: result.extend(b[b_idx:block[1]]) a_idx = block[0]+block[-1] b_idx = block[1]+block[-1] result.extend(a[block[0]:block[0]+block[-1]]) if a_idx < len(a): result.extend(a[a_idx:]) if b_idx < len(b): result.extend(b[b_idx:]) return result def multimerge(candidates, merge_func=merge): candidates = list(candidates) while len(candidates) > 1: a, b, res = multimerge_(candidates, merge_func) if res is None: return candidates candidates.remove(b) if a is not res: candidates.remove(a) candidates.append(res) # else: in place merge return candidates[0] def multimerge_(candidates, merge_func): for a, b in permutations(candidates, 2): res = merge_func(a, b) if res is not None: return a, b, res return None, None, None try: from itertools import permutations permutations # prevent warning except ImportError: def permutations(iterable, r=None): # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC # permutations(range(3)) --> 012 021 102 120 201 210 pool = tuple(iterable) n = len(pool) r = n if r is None else r if r > n: return indices = range(n) cycles = range(n, n-r, -1) yield tuple(pool[i] for i in indices[:r]) while n: for i in reversed(range(r)): cycles[i] -= 1 if cycles[i] == 0: indices[i:] = indices[i+1:] + indices[i:i+1] cycles[i] = n - i else: j = cycles[i] indices[i], indices[-j] = indices[-j], indices[i] yield tuple(pool[i] for i in indices[:r]) break else: returnimposm-2.6.0/imposm/multipolygon.py0000644000076500000240000003412412454213016017366 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import division import os import time from imposm.geom import ( PolygonBuilder, LineStringBuilder, InvalidGeometryError, IncompletePolygonError, ) from imposm.merge import merge import imposm.base import imposm.geom import imposm.config import shapely.geometry import shapely.ops import shapely.geos import shapely.prepared import logging log = logging.getLogger(__name__) def RelationBuilder(*args, **kw): if imposm.config.relation_builder == 'contains': return ContainsRelationBuilder(*args, **kw) if imposm.config.relation_builder == 'union': return UnionRelationBuilder(*args, **kw) raise ValueError('unknown relation_builder "%s"' % (imposm.config.relation_builder, )) class RelationBuilderBase(object): validate_rings = True def __init__(self, relation, ways_cache, coords_cache): self.relation = relation self.polygon_builder = PolygonBuilder() self.linestring_builder = LineStringBuilder() self.ways_cache = ways_cache self.coords_cache = coords_cache def fetch_ways(self): ways = [] for member in self.relation.members: # skip label nodes, relations of relations, etc if member[1] != 'way': continue way = self.ways_cache.get(member[0]) if way is None: log.debug('way not found %s:%s', self.relation.osm_id, member[0]) if imposm.config.import_partial_relations: continue else: raise IncompletePolygonError('way not found %s:%s' % (self.relation.osm_id, member[0])) if way.partial_refs: log.warn('multiple linestrings in way %s (relation %s)', member[0], self.relation.osm_id) raise IncompletePolygonError() way.coords = self.fetch_way_coords(way) if way.coords is None: if not imposm.config.import_partial_relations: raise IncompletePolygonError() else: ways.append(way) return ways def build_rings(self, ways): rings = [] incomplete_rings = [] for ring in (Ring(w) for w in ways): if ring.is_closed(): ring.geom = self.polygon_builder.build_checked_geom(ring, validate=self.validate_rings) rings.append(ring) else: incomplete_rings.append(ring) merged_rings = self.build_ring_from_incomplete(incomplete_rings) if len(rings) + len(merged_rings) == 0: raise IncompletePolygonError('linestrings from relation %s have no rings' % (self.relation.osm_id, )) return rings + merged_rings def build_ring_from_incomplete(self, incomplete_rings): rings = merge_rings(incomplete_rings) for ring in rings[:]: if not ring.is_closed(): if imposm.config.import_partial_relations: rings.remove(ring) continue else: raise InvalidGeometryError('linestrings from relation %s do not form a ring' % self.relation.osm_id) ring.geom = self.polygon_builder.build_checked_geom(ring, validate=self.validate_rings) return rings def fetch_way_coords(self, way): """ Fetch all coordinates of way.refs. """ coords = self.coords_cache.get_coords(way.refs) if coords is None: log.debug('missing coord from way %s in relation %s', way.osm_id, self.relation.osm_id) return None return coords def build_relation_geometry(self, rings): """ Build relation geometry from rings. """ raise NotImplementedError() def build(self): try: time_start = time.time() ways = self.fetch_ways() time_ways = time.time() - time_start if not ways: raise IncompletePolygonError('no ways found') time_start = time.time() rings = self.build_rings(ways) time_rings = time.time() - time_start if (imposm.config.imposm_multipolygon_max_ring and len(rings) > imposm.config.imposm_multipolygon_max_ring): log.warn('skipping relation %d with %d ways (%.1fms) and %d rings (%.1fms): too many rings', self.relation.osm_id, len(ways), time_ways*1000, len(rings), time_rings*1000) raise IncompletePolygonError('skipping too large multipolygon') time_start = time.time() self.build_relation_geometry(rings) time_relations = time.time() - time_start if time_ways + time_rings + time_relations > imposm.config.imposm_multipolygon_report: log.warn('building relation %d with %d ways (%.1fms) and %d rings (%.1fms) took %.1fms', self.relation.osm_id, len(ways), time_ways*1000, len(rings), time_rings*1000, time_relations*1000) except InvalidGeometryError, ex: log.debug(ex) raise IncompletePolygonError(ex) except IncompletePolygonError: raise except Exception, ex: log.warn('error while building multipolygon:') log.exception(ex) raise IncompletePolygonError(ex) class UnionRelationBuilder(RelationBuilderBase): def build_relation_geometry(self, rings): """ Build relation geometry from rings. """ rings.sort(key=lambda x: x.geom.area, reverse=True) # add/subtract all rings from largest polygon = rings[0] rel_tags = relation_tags(self.relation.tags, polygon.tags) polygon.mark_as_inserted(rel_tags) geom = polygon.geom for r in rings[1:]: if geom.contains(r.geom): # inside -> hole -> subtract geom = geom.difference(r.geom) r.mark_as_inserted(rel_tags) else: # outside or overlap -> merge(union) to multipolygon or to polygon try: geom = geom.union(r.geom) except shapely.geos.TopologicalError: raise InvalidGeometryError('multipolygon relation (%s) result is invalid' ' (topological error)' % self.relation.osm_id) r.mark_as_inserted(rel_tags) if not geom.is_valid: raise InvalidGeometryError('multipolygon relation (%s) result is invalid' % self.relation.osm_id) self.relation.geom = geom self.relation.tags = rel_tags all_ways = polygon.ways for r in rings: all_ways.extend(r.ways) self.relation.ways = all_ways class ContainsRelationBuilder(RelationBuilderBase): validate_rings = False def _ring_is_hole(self, rings, idx): """ Returns True if rings[idx] is a hole, False if it is a shell (also if hole in a hole, etc) """ contained_counter = 0 while True: idx = rings[idx].contained_by if idx is None: break contained_counter += 1 return contained_counter % 2 == 1 def build_relation_geometry(self, rings): """ Build relation geometry from rings. """ rings.sort(key=lambda x: x.geom.area, reverse=True) total_rings = len(rings) shells = set([rings[0]]) for i in xrange(total_rings): test_geom = shapely.prepared.prep(rings[i].geom) for j in xrange(i+1, total_rings): if test_geom.contains(rings[j].geom): # j in inside of i if rings[j].contained_by is not None: # j is inside a larger ring, remove that relationship # e.g. j is hole inside a hole (i) rings[rings[j].contained_by].holes.discard(rings[j]) shells.discard(rings[j]) # remember parent rings[j].contained_by = i # add ring as hole or shell if self._ring_is_hole(rings, j): rings[i].holes.add(rings[j]) else: shells.add(rings[j]) if rings[i].contained_by is None: # add as shell if it is not a hole shells.add(rings[i]) rel_tags = relation_tags(self.relation.tags, rings[0].tags) # build polygons from rings polygons = [] for shell in shells: shell.mark_as_inserted(rel_tags) exterior = shell.geom.exterior interiors = [] for hole in shell.holes: hole.mark_as_inserted(rel_tags) interiors.append(hole.geom.exterior) polygons.append(shapely.geometry.Polygon(exterior, interiors)) if len(polygons) == 1: geom = polygons[0] else: geom = shapely.geometry.MultiPolygon(polygons) geom = imposm.geom.validate_and_simplify(geom) if not geom.is_valid: raise InvalidGeometryError('multipolygon relation (%s) result is invalid' % self.relation.osm_id) self.relation.geom = geom self.relation.tags = rel_tags all_ways = [] for r in rings: all_ways.extend(r.ways) self.relation.ways = all_ways def relation_tags(rel_tags, way_tags): result = dict(rel_tags) if 'type' in result: del result['type'] if 'name' in result: del result['name'] if not result: # use way_tags result.update(way_tags) else: if 'name' in rel_tags: # put back name result['name'] = rel_tags['name'] return result def tags_differ(a, b): a_ = dict(a) a_.pop('name', None) b_ = dict(b) b_.pop('name', None) return a_ != b_ def tags_same_or_empty(a, b): return ( not b or not tags_differ(a, b) ) def merge_rings(rings): """ Merge rings at the endpoints. """ endpoints = {} for ring in rings: if len(ring.refs) < 2: continue left = ring.refs[0] right = ring.refs[-1] orig_ring = None if left in endpoints: orig_ring = endpoints.pop(left) if left == orig_ring.refs[-1]: orig_ring.refs = orig_ring.refs + ring.refs[1:] orig_ring.coords = orig_ring.coords + ring.coords[1:] else: orig_ring.refs = orig_ring.refs[::-1] + ring.refs[1:] orig_ring.coords = orig_ring.coords[::-1] + ring.coords[1:] orig_ring.ways.extend(ring.ways) orig_ring.tags.update(ring.tags) if right in endpoints and endpoints[right] is not orig_ring: # close gap ring = endpoints.pop(right) if right == ring.refs[0]: orig_ring.refs = orig_ring.refs + ring.refs[1:] orig_ring.coords = orig_ring.coords + ring.coords[1:] else: orig_ring.refs = orig_ring.refs[:-1] + ring.refs[::-1] orig_ring.coords = orig_ring.coords[:-1] + ring.coords[::-1] orig_ring.ways.extend(ring.ways) orig_ring.tags.update(ring.tags) right = orig_ring.refs[-1] endpoints[right] = orig_ring else: endpoints[right] = orig_ring elif right in endpoints: orig_ring = endpoints.pop(right) if right == orig_ring.refs[0]: orig_ring.refs = ring.refs[:-1] + orig_ring.refs orig_ring.coords = ring.coords[:-1] + orig_ring.coords else: orig_ring.refs = orig_ring.refs[:-1] + ring.refs[::-1] orig_ring.coords = orig_ring.coords[:-1] + ring.coords[::-1] orig_ring.ways.extend(ring.ways) orig_ring.tags.update(ring.tags) endpoints[left] = orig_ring else: endpoints[left] = ring endpoints[right] = ring return list(set(endpoints.values())) class Ring(object): """ Represents a ring (i.e. polygon without holes) build from one or more ways. Stores references to the building ways. """ def __init__(self, way): self.ways = [way] self.osm_id = way.osm_id self.refs = way.refs self.coords = way.coords self.tags = dict(way.tags) self.inserted = way.inserted self.contained_by = None self.holes = set() def __repr__(self): return 'Ring(%r, %r, %r)' % (self.osm_id, self.tags, self.ways) def merge(self, ring, without_refs=False): """ Try to merge `ring.refs` with this ring. Returns `self` on success, else `None`. """ if without_refs: result = None else: result = merge(self.refs, ring.refs) if result is None: return None self.ways.extend(ring.ways) self.refs = [result] self.tags.update(ring.tags) return self def is_closed(self): return len(self.refs) >= 4 and self.refs[0] == self.refs[-1] def mark_as_inserted(self, tags): for w in self.ways: if tags_same_or_empty(tags, w.tags): w.inserted = True if tags_same_or_empty(tags, self.tags): self.inserted = True imposm-2.6.0/imposm/psqldb.py0000644000076500000240000001145012147670245016120 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import optparse import string from os.path import join, dirname, exists db_create_template = """ # run this as postgres user, eg: # imposm-psqldb > create_db.sh; sudo su postgres; sh ./create_db.sh set -xe createuser --no-superuser --no-createrole --createdb ${user} createdb -E UTF8 -O ${user} ${dbname} createlang plpgsql ${dbname} ${postgis} echo "ALTER TABLE spatial_ref_sys OWNER TO ${user};" | psql -d ${dbname} echo "ALTER USER ${user} WITH PASSWORD '${password}';" |psql -d ${dbname} echo "host\t${dbname}\t${user}\t127.0.0.1/32\tmd5" >> ${pg_hba} set +x echo "Done. Don't forget to restart postgresql!" """.strip() postgis_create_template_15 = """ psql -d ${dbname} -f ${postgis_sql} psql -d ${dbname} -f ${spatial_ref_sys_sql} psql -d ${dbname} -f ${epsg900913_sql} echo "ALTER TABLE geometry_columns OWNER TO ${user};" | psql -d ${dbname} """.strip() postgis_create_template_20 = """ echo "CREATE EXTENSION postgis;" | psql -d ${dbname} echo "ALTER TABLE geometry_columns OWNER TO ${user};" | psql -d ${dbname} psql -d ${dbname} -f ${epsg900913_sql} """.strip() def find_sql_files(version, postgis_version, mapping): pg_hba = '/path/to/pg_hba.conf \t# <- CHANGE THIS PATH' postgis_sql = '/path/to/postgis.sql \t\t\t\t# <- CHANGE THIS PATH' spatial_ref_sys_sql = '/path/to/spatial_ref_sys.sql \t\t\t# <- CHANGE THIS PATH' if version in ('8.3', 'auto'): p = '/usr/share/postgresql-8.3-postgis/lwpostgis.sql' if exists(p): postgis_sql = p p = '/usr/share/postgresql-8.3-postgis/spatial_ref_sys.sql' if exists(p): spatial_ref_sys_sql = p p = '/etc/postgresql/8.3/main/pg_hba.conf' if exists(p): pg_hba = p if version in ('8.4', 'auto'): p = '/usr/share/postgresql/8.4/contrib/postgis.sql' if exists(p): postgis_sql = p p = '/usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql' if exists(p): postgis_sql = p p = '/usr/share/postgresql/8.4/contrib/spatial_ref_sys.sql' if exists(p): spatial_ref_sys_sql = p p = '/usr/share/postgresql/8.4/contrib/postgis-1.5/spatial_ref_sys.sql' if exists(p): spatial_ref_sys_sql = p p = '/etc/postgresql/8.4/main/pg_hba.conf' if exists(p): pg_hba = p if version in ('9.1', 'auto'): p = '/usr/share/postgresql/9.1/contrib/postgis-1.5/postgis.sql' if exists(p): postgis_sql = p p = '/usr/share/postgresql/9.1/contrib/postgis-1.5/spatial_ref_sys.sql' if exists(p): spatial_ref_sys_sql = p p = '/etc/postgresql/9.1/main/pg_hba.conf' if exists(p): pg_hba = p if postgis_version == '2.0': postgis_sql = None spatial_ref_sys_sql = None mapping['postgis_sql'] = postgis_sql mapping['spatial_ref_sys_sql'] = spatial_ref_sys_sql mapping['pg_hba'] = pg_hba mapping['pg_version'] = postgis_version def main(): usage = '%prog [options]' desc = 'Outputs shell commands to create a PostGIS database.' parser = optparse.OptionParser(usage=usage, description=desc) parser.add_option('--database', dest='dbname', metavar='osm', default='osm') parser.add_option('--user', dest='user', metavar='osm', default='osm') parser.add_option('--password', dest='password', metavar='osm', default='osm') parser.add_option('--pg-version', dest='pg_version', metavar='8.3|8.4|9.1|auto', default='auto') parser.add_option('--postgis-version', dest='postgis_version', metavar='1.5|2.0', default='1.5') (options, args) = parser.parse_args() mapping = { 'user': options.user, 'dbname': options.dbname, 'password': options.password, } mapping['epsg900913_sql'] = join(dirname(__file__), '900913.sql') find_sql_files(options.pg_version, options.postgis_version, mapping) if options.postgis_version == '2.0': mapping['postgis'] = string.Template(postgis_create_template_20).substitute(mapping) else: mapping['postgis'] = string.Template(postgis_create_template_15).substitute(mapping) template = string.Template(db_create_template) print template.substitute(mapping) if __name__ == '__main__': main() imposm-2.6.0/imposm/reader.py0000644000076500000240000001175012147670245016100 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from functools import partial from multiprocessing import Process, JoinableQueue from imposm.parser import OSMParser from imposm.util import setproctitle class ImposmReader(object): def __init__(self, mapping, cache, pool_size=2, merge=False, logger=None): self.pool_size = pool_size self.mapper = mapping self.merge = merge self.cache = cache self.reader = None self.logger = logger self.estimated_coords = 0 def read(self, filename): nodes_queue = JoinableQueue(128) coords_queue = JoinableQueue(512) ways_queue = JoinableQueue(128) relations_queue = JoinableQueue(128) log_proc = self.logger() log_proc.start() marshal = True if self.merge: # merging needs access to unmarshaled data marshal = False estimates = { 'coords': self.estimated_coords, 'nodes': self.estimated_coords//50, 'ways': self.estimated_coords//7, 'relations': self.estimated_coords//1000, } coords_writer = CacheWriterProcess(coords_queue, self.cache.coords_cache, estimates['coords'], log=partial(log_proc.log, 'coords'), marshaled_data=marshal) coords_writer.start() nodes_writer = CacheWriterProcess(nodes_queue, self.cache.nodes_cache, estimates['nodes'], log=partial(log_proc.log, 'nodes'), marshaled_data=marshal) nodes_writer.start() ways_writer = CacheWriterProcess(ways_queue, self.cache.ways_cache, estimates['ways'], merge=self.merge, log=partial(log_proc.log, 'ways'), marshaled_data=marshal) ways_writer.start() relations_writer = CacheWriterProcess(relations_queue, self.cache.relations_cache, estimates['relations'], merge=self.merge, log=partial(log_proc.log, 'relations'), marshaled_data=marshal) relations_writer.start() log_proc.message('coords: %dk nodes: %dk ways: %dk relations: %dk (estimated)' % ( estimates['coords']/1000, estimates['nodes']/1000, estimates['ways']/1000, estimates['relations']/1000) ) # keep one CPU free for writer proc on hosts with 4 or more CPUs pool_size = self.pool_size if self.pool_size < 4 else self.pool_size - 1 parser = OSMParser(pool_size, nodes_callback=nodes_queue.put, coords_callback=coords_queue.put, ways_callback=ways_queue.put, relations_callback=relations_queue.put, marshal_elem_data=marshal) parser.nodes_tag_filter = self.mapper.tag_filter_for_nodes() parser.ways_tag_filter = self.mapper.tag_filter_for_ways() parser.relations_tag_filter = self.mapper.tag_filter_for_relations() parser.parse(filename) coords_queue.put(None) nodes_queue.put(None) ways_queue.put(None) relations_queue.put(None) coords_writer.join() nodes_writer.join() ways_writer.join() relations_writer.join() log_proc.stop() log_proc.join() class CacheWriterProcess(Process): def __init__(self, queue, cache, estimated_records=None, merge=False, log=None, marshaled_data=False): Process.__init__(self) self.daemon = True setproctitle('imposm writer') self.queue = queue self.cache = cache self.merge = merge self.log = log self.marshaled_data = marshaled_data self.estimated_records = estimated_records def run(self): # print 'creating %s (%d)' % (self.filename, self.estimated_records or 0) cache = self.cache(mode='w', estimated_records=self.estimated_records) if self.marshaled_data: cache_put = cache.put_marshaled else: cache_put = cache.put while True: data = self.queue.get() if data is None: self.queue.task_done() break if self.merge: for d in data: if d[0] in cache: elem = cache.get(d[0]) elem.merge(*d[1:]) d = elem.to_tuple() cache_put(*d) else: for d in data: cache_put(*d) if self.log: self.log(len(data)) self.queue.task_done() cache.close() imposm-2.6.0/imposm/test/0000755000076500000240000000000012454222732015232 5ustar oltstaff00000000000000imposm-2.6.0/imposm/test/__init__.py0000644000076500000240000000000011766043214017332 0ustar oltstaff00000000000000imposm-2.6.0/imposm/test/test_cache.py0000644000076500000240000000732611766043214017717 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import tempfile from imposm.cache.tc import NodeDB, CoordDB, DeltaCoordsDB from nose.tools import eq_, assert_almost_equal class TestNodeDB(object): def setup(self): fd_, self.fname = tempfile.mkstemp('.db') self.db = NodeDB(self.fname) def teardown(self): os.unlink(self.fname) def test_insert(self): assert self.db.put(1000, {'foo': 2}, (123, 456)) assert self.db.put(2**40, {'bar': 2}, (123, 456)) nd = self.db.get(1000) eq_(nd.osm_id, 1000) eq_(nd.tags, {'foo': 2}) eq_(nd.coord, (123, 456)) nd = self.db.get(2**40) eq_(nd.osm_id, 2**40) def test_read_only(self): assert self.db.put(1000, {'foo': 2}, (123, 456)) assert self.db.put(2**40, {'bar': 2}, (123, 456)) self.db.close() self.db = NodeDB(self.fname, 'r') nd = self.db.get(1000) eq_(nd.osm_id, 1000) eq_(nd.tags, {'foo': 2}) eq_(nd.coord, (123, 456)) nd = self.db.get(2**40) eq_(nd.osm_id, 2**40) assert not self.db.put(1001, {'foo': 2}, (123, 456)) assert not self.db.get(1001) def test_iter(self): assert self.db.put(1000, {'foo': 2}, (123, 456)) nds = list(self.db) eq_(len(nds), 1) nd = nds[0] eq_(nd.osm_id, 1000) eq_(nd.tags, {'foo': 2}) eq_(nd.coord, (123, 456)) class TestCoordDB(object): testclass = CoordDB def setup(self): fd_, self.fname = tempfile.mkstemp('.db') self.db = self.testclass(self.fname) def teardown(self): os.unlink(self.fname) def test_insert(self): assert self.db.put(1000, 123, 179.123456789) assert self.db.put(2**40, 123, 179.123456789) assert self.db.put(2**40+1, 123, 179.123456789) pos = self.db.get(1000) assert_almost_equal(pos[0], 123.0, 6) assert_almost_equal(pos[1], 179.123456789, 6) assert self.db.get(2**40) assert self.db.get(2**40+1) def test_read_only(self): assert self.db.put(1000, 123, 0) assert self.db.put(1001, -180.0, -90) assert self.db.put(1010, 180, 90) assert self.db.put(2**40, 123, 179.123456789) assert self.db.put(2**40+1, 123, 179.123456789) self.db.close() self.db = self.testclass(self.fname, 'r') pos = self.db.get(1000) assert_almost_equal(pos[0], 123.0, 6) assert_almost_equal(pos[1], 0.0, 6) pos = self.db.get(1001) assert_almost_equal(pos[0], -180.0, 6) assert_almost_equal(pos[1], -90.0, 6) pos = self.db.get(1010) assert_almost_equal(pos[0], 180.0, 6) assert_almost_equal(pos[1], 90.0, 6) assert self.db.get(2**40) assert self.db.get(2**40+1) assert not self.db.put(2001, 123, 456) assert not self.db.get(2001) class TestDeltaCoordDB(TestCoordDB): testclass = DeltaCoordsDB def setup(self): fd_, self.fname = tempfile.mkstemp('.db') self.db = DeltaCoordsDB(self.fname) imposm-2.6.0/imposm/test/test_dbimporter.py0000644000076500000240000000737212147670245021030 0ustar oltstaff00000000000000# Copyright 2012 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from imposm.dbimporter import DictBasedImporter, TupleBasedImporter from imposm import defaultmapping from nose.tools import eq_, assert_almost_equal class TestDictBasedImporter(object): def setup(self): dummy_db = None mapper = None self.importer = DictBasedImporter(None, dummy_db, mapper, None, dry_run=False) def test_insert(self): mappings = [ (('highway', 'secondary'), [defaultmapping.mainroads]), (('railway', 'tram'), [defaultmapping.railways]), (('landusage', 'grass'), [defaultmapping.landusages]), ] assert self.importer.insert(mappings, 1234, [(0, 0), (1, 0), (1, 1), (0, 0)], {'highway': 'secondary', 'railway': 'tram', 'oneway': '1', 'name': 'roundabout', } ) # get items, sort by mapping_names so that landusages comes first queue_items = [self.importer.db_queue.get(), self.importer.db_queue.get()] queue_items.sort(key=lambda x: x['mapping_names']) polygon_item = queue_items[0] linestring_item = queue_items[1] eq_(linestring_item['mapping_names'], ['mainroads', 'railways']) eq_(linestring_item['osm_id'], 1234) eq_(linestring_item['fields'], { 'highway': 'secondary', 'railway': 'tram', 'oneway': 1, 'z_order': 7, 'bridge': 0, 'tunnel': 0, 'name': 'roundabout', 'ref': None }) eq_(polygon_item['mapping_names'], ['landusages']) eq_(polygon_item['osm_id'], 1234) assert_almost_equal(polygon_item['fields']['area'], 6195822904.182782) del polygon_item['fields']['area'] eq_(polygon_item['fields'], { 'z_order': 27, 'landusage': 'grass', 'name': 'roundabout', }) class TestTupleBasedImporter(object): def setup(self): dummy_db = None mapper = None self.importer = TupleBasedImporter(None, dummy_db, mapper, None, dry_run=False) def test_insert(self): mappings = [ (('highway', 'secondary'), [defaultmapping.mainroads]), (('railway', 'tram'), [defaultmapping.railways]), (('landusage', 'grass'), [defaultmapping.landusages]), ] assert self.importer.insert(mappings, 1234, [(0, 0), (1, 0), (1, 1), (0, 0)], {'highway': 'secondary', 'railway': 'tram', 'oneway': '1', 'name': 'roundabout', } ) mainroads_item = self.importer.db_queue.get() eq_(mainroads_item[0], defaultmapping.mainroads) eq_(mainroads_item[1], 1234) eq_(mainroads_item[3], ['roundabout', 'secondary', 0, 0, 1, None, 5]) railways_item = self.importer.db_queue.get() eq_(railways_item[0], defaultmapping.railways) eq_(railways_item[1], 1234) eq_(railways_item[3], ['roundabout', 'tram', 0, 0, 7]) landusages_item = self.importer.db_queue.get() eq_(landusages_item[0], defaultmapping.landusages) eq_(landusages_item[1], 1234) eq_(landusages_item[3], ['roundabout', 'grass', 6195822904.182782, 27]) imposm-2.6.0/imposm/test/test_field_types.py0000644000076500000240000000325111766043214021154 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import imposm from imposm.base import OSMElem from imposm.mapping import Name, LocalizedName def test_name_field(): name = Name() elem = OSMElem(1, [], 'test', tags={'name': 'fixme'}) assert name.value('fixme', elem) == '' assert elem.name == '' elem = OSMElem(1, [], 'test', tags={'name': 'Foo Street'}) assert name.value('Foo Street', elem) == 'Foo Street' assert elem.name == 'Foo Street' def test_localized_name_field(): name = LocalizedName(['name:de', 'name:en', 'foo']) elem = OSMElem(1, [], 'test', tags={'name': 'Foo'}) assert name.value(None, elem) == '' assert elem.name == '' elem = OSMElem(1, [], 'test', tags={'name:de': 'Foo', 'name:en': 'Bar'}) assert name.value(None, elem) == 'Foo' assert elem.name == 'Foo' elem = OSMElem(1, [], 'test', tags={'name:es': 'Foo', 'name:en': 'Bar'}) assert name.value(None, elem) == 'Bar' assert elem.name == 'Bar' elem = OSMElem(1, [], 'test', tags={'name:es': 'Foo', 'foo': 'Bar'}) assert name.value(None, elem) == 'Bar' assert elem.name == 'Bar' imposm-2.6.0/imposm/test/test_imported.py0000644000076500000240000000735212147670245020502 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import re import os import tempfile import shutil from contextlib import contextmanager import imposm.app import imposm.db.config import imposm.mapping from nose.tools import eq_ from nose.plugins import skip temp_dir = None old_cwd = None try: from imposm_test_conf import db_conf db_conf = imposm.mapping.Options(db_conf) except ImportError: raise skip.SkipTest('no imposm_test_conf.py with db_conf found') def setup_module(): global old_cwd, temp_dir old_cwd = os.getcwd() temp_dir = tempfile.mkdtemp() os.chdir(temp_dir) test_osm_file = os.path.join(os.path.dirname(__file__), 'test.out.osm') with capture_out(): print db_conf.password imposm.app.main(['--read', test_osm_file, '--write', '--proj', db_conf.proj, '--table-prefix', db_conf.prefix, '--connect', 'postgis://%(user)s:%(password)s@%(host)s:%(port)s/%(db)s' % db_conf]) class TestImported(object): def __init__(self): self.db = imposm.db.config.DB(db_conf) def test_point(self): cur = self.db.cur cur.execute('select osm_id, name, ST_AsText(geometry) from %splaces where osm_id = 1' % db_conf.prefix) results = cur.fetchall() eq_(len(results), 1) eq_(results[0], (1, 'Foo', 'POINT(13 47.5)')) def test_way(self): cur = self.db.cur cur.execute('select osm_id, name, ST_AsText(geometry) from %slandusages where osm_id = 1001' % db_conf.prefix) results = cur.fetchall() eq_(len(results), 1) eq_(results[0][:-1], (1001, 'way 1001',)) eq_(roundwkt(results[0][-1]), 'POLYGON((13.0 47.5,14.5 50.0,16.5 49.0,17.0 47.0,14.5 45.5,13.0 47.5),(14.0 47.5,15.0 47.0,15.5 48.0,14.5 48.5,14.0 47.5))') cur.execute('select osm_id, name, ST_AsText(geometry) from %slandusages where osm_id = 2001' % db_conf.prefix) results = cur.fetchall() eq_(len(results), 1) eq_(results[0][:-1], (2001, 'way 2001',)) eq_(roundwkt(results[0][-1]), 'POLYGON((23.0 47.5,24.5 50.0,26.5 49.0,27.0 47.0,24.5 45.5,23.0 47.5),(24.5 47.0,25.5 46.5,26.0 47.5,25.0 47.5,24.5 47.0),(24.2 48.25,25.25 47.7,25.7 48.8,24.7 49.25,24.2 48.25))') cur.execute('select osm_id, name, ST_AsText(geometry) from %slandusages where osm_id = 3001' % db_conf.prefix) results = cur.fetchall() eq_(len(results), 1) eq_(results[0][:-1], (3001, 'way 3002',)) eq_(roundwkt(results[0][-1]), 'POLYGON((33.0 47.5,34.5 50.0,36.5 49.0,37.0 47.0,34.5 45.5,33.0 47.5),(34.0 47.5,35.0 47.0,35.5 48.0,34.5 48.5,34.0 47.5))') def roundwkt(wkt): def round_num(num_str): return str(round(float(num_str.group(0)), 2)) return re.sub('\d+(\.\d+)?', round_num, wkt) def teardown_module(): if old_cwd: os.chdir(old_cwd) if temp_dir and os.path.exists(temp_dir): shutil.rmtree(temp_dir) @contextmanager def capture_out(): import sys from cStringIO import StringIO old_stdout = sys.stdout old_stderr = sys.stderr try: sys.stdout = StringIO() sys.stderr = StringIO() yield sys.stdout, sys.stderr finally: sys.stdout = old_stdout sys.stderr = old_stderr imposm-2.6.0/imposm/test/test_large_limit_to_geom.py0000644000076500000240000000265612140411240022637 0ustar oltstaff00000000000000import sys from imposm.geom import load_geom from shapely import geometry, wkt import json def dump_featurecollection(geoms, out): result = {'type': 'FeatureCollection', 'features': []} for geom in geoms: result['features'].append({ 'type': 'Feature', 'geometry': geometry.mapping(geom), 'properties': {}, }) json.dump(result, out) def test_limit(): rtree_limit = load_geom(sys.argv[1]) result = {'type': 'FeatureCollection', 'features': []} for geom in rtree_limit.polygons: result['features'].append({ 'type': 'Feature', 'geometry': geometry.mapping(geom), 'properties': {}, }) json.dump(result, open('/tmp/1-test-10.geojson', 'w')) def test_clip(): poly = geometry.asShape(json.load(open('/tmp/complete.geojson'))) bbox = geometry.Polygon([(7.7, 49.1), (7.8, 49.1), (7.8, 49.2), (7.7, 49.2), (7.7, 49.1)]) bbox = geometry.Polygon([(7.8, 49.1), (7.7, 49.1), (7.7, 49.2), (7.8, 49.2), (7.8, 49.1)]) bbox = wkt.loads('POLYGON ((7.7999999999999998 49.1000000000000014, 7.7000000000000002 49.1000000000000014, 7.7000000000000002 49.2000000000000028, 7.7999999999999998 49.2000000000000028, 7.7999999999999998 49.1000000000000014))') intersect = bbox.intersection(poly) dump_featurecollection([intersect], open('/tmp/part-intersect.geojson', 'w')) if __name__ == '__main__': test_clip() imposm-2.6.0/imposm/test/test_limit_to.py0000644000076500000240000000743612147670245020502 0ustar oltstaff00000000000000# Copyright 2012 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from imposm.geom import LimitPolygonGeometry, EmtpyGeometryError from shapely.wkt import loads from nose.tools import raises class TestLimitPolygonGeometry(object): @raises(EmtpyGeometryError) def test_linestring_no_intersection(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) limit_to.intersection(loads('LINESTRING(-100 -100, -50 -50)')) def test_linestring(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) geom = limit_to.intersection(loads('LINESTRING(-10 -10, 20 20)')) assert geom.almost_equals(loads('LINESTRING(0 0, 10 10)')) def test_linestring_contained(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) test_geom = loads('LINESTRING(1 1, 9 9)') geom = limit_to.intersection(test_geom) # should return unmodified input geometry assert geom is test_geom def test_linestring_multilinestring_result(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) geom = limit_to.intersection(loads('LINESTRING(-10 -20, 5 10, 20 -20)')) assert isinstance(geom, list) assert geom[0].almost_equals(loads('LINESTRING(0 0, 5 10)')) assert geom[1].almost_equals(loads('LINESTRING(5 10, 10 0)')) @raises(EmtpyGeometryError) def test_linestring_point_result(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) geom = limit_to.intersection(loads('LINESTRING(-10 -10, 0 0)')) def test_linestring_mixed_result(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) geom = limit_to.intersection(loads('LINESTRING(0 0, 5 -10, 5 10)')) # point and linestring, point not returned assert isinstance(geom, list) assert len(geom) == 1 assert geom[0].almost_equals(loads('LINESTRING(5 0, 5 10)')) def test_polygon_mixed_result(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) test_geom = loads('POLYGON((0 -10, 0 5, 2.5 -5, 5 0, 7.5 -5, 10 5, 10 -10, 0 -10))') geom = limit_to.intersection(test_geom) # point and two polygons, point not returned assert isinstance(geom, list) assert len(geom) == 2 assert geom[0].almost_equals(loads('POLYGON((1.25 0, 0 0, 0 5, 1.25 0))')) assert geom[1].almost_equals(loads('POLYGON((10 0, 8.75 0, 10 5, 10 0))')) def test_polygon_multipolygon_result(self): geom = 'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))' limit_to = LimitPolygonGeometry(loads(geom)) test_geom = loads('POLYGON((0 -10, 0 5, 2.5 -5, 5 -1, 7.5 -5, 10 5, 10 -10, 0 -10))') geom = limit_to.intersection(test_geom) # similar to above, but point does not touch the box, so we should get # a single multipolygon assert geom.almost_equals(loads( 'MULTIPOLYGON(((1.25 0, 0 0, 0 5, 1.25 0)),' '((10 0, 8.75 0, 10 5, 10 0)))')) imposm-2.6.0/imposm/test/test_multipolygon.py0000644000076500000240000003277212147670124021421 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from imposm.base import Relation, Way from imposm.multipolygon import UnionRelationBuilder, ContainsRelationBuilder, Ring, merge_rings from nose.tools import eq_, assert_almost_equal class RelationBuilderTestBase(object): def test_broken_polygon_self_intersect(self): # 2##3 6##7 # # # #### # 1##4____5##8 w1 = Way(1, {}, [1, 2, 3, 4, 5, 6, 7, 8, 1]) w1.coords = [(0, 0), (0, 10), (10, 10), (10, 0), (20, 0), (20, 10), (30, 10), (30, 0), (0, 0)] w2 = Way(2, {}, [15, 16, 17, 18, 15]) w2.coords = [(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)] yield self.check_broken_polygon, w1, w2 # 2##3 6##7 # # # #### # 1##4____5##8 w1 = Way(1, {}, [4, 1, 2, 3, 4, 5, 6, 7, 8, 4]) w1.coords = [(10, 0), (0, 0), (0, 10), (10, 10), (10, 0), (20, 0), (20, 10), (30, 10), (30, 0), (10, 0)] yield self.check_broken_polygon, w1, w2 def check_broken_polygon(self, w1, w2): r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) eq_(len(rings), 2) eq_(rings[0].geom.area, 200) eq_(rings[1].geom.area, 36) builder.build_relation_geometry(rings) eq_(r.geom.area, 200-36) def test_broken_polygon_self_intersect_triangle(self): # 2### # # ###4 # # ###3 # 1### # triangle with four points, minor overlapping w1 = Way(1, {}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (0, 100), (100, 50 - 0.00001), (100, 50 + 0.00001), (0, 0)] w2 = Way(2, {}, [15, 16, 17, 18, 15]) w2.coords = [(10, 45), (10, 55), (20, 55), (20, 45), (10, 45)] r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) eq_(len(rings), 2) assert_almost_equal(rings[0].geom.area, 100 * 100 / 2, 2) eq_(rings[1].geom.area, 100) builder.build_relation_geometry(rings) assert_almost_equal(r.geom.area, 100 * 100 / 2 - 100, 2) # larger overlapp w1 = Way(1, {}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (0, 100), (100, 50 - 1), (100, 50 + 1), (0, 0)] w2 = Way(2, {}, [15, 16, 17, 18, 15]) w2.coords = [(10, 45), (10, 55), (20, 55), (20, 45), (10, 45)] r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) eq_(len(rings), 2) assert_almost_equal(rings[0].geom.area, 100 * 100 / 2, -3) eq_(rings[1].geom.area, 100) builder.build_relation_geometry(rings) assert_almost_equal(r.geom.area, 100 * 100 / 2 - 100, -3) # # 2### ###4 # # # ### # # # # ### # # # 1### ###3 # # hourglass # w1 = Way(1, {}, [1, 2, 3, 4, 1]) # w1.coords = [(0, 0), (0, 100), (100, 0), (100, 100), (0, 0)] # w2 = Way(2, {}, [15, 16, 17, 18, 15]) # w2.coords = [(10, 45), (10, 55), (20, 55), (20, 45), (10, 45)] # w3 = Way(3, {}, [25, 26, 27, 28, 25]) # w3.coords = [(80, 45), (80, 55), (90, 55), (90, 45), (80, 45)] # # r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) # builder = self.relation_builder(r, None, None) # rings = builder.build_rings([w1, w2, w3]) # eq_(len(rings), 3) # print rings[0].geom.wkt, rings[0].geom.simplify(0.000001, False).wkt # eq_(rings[0].geom.area, 100 * 100 / 2) # eq_(rings[1].geom.area, 100) # eq_(rings[2].geom.area, 100) # # builder.build_relation_geometry(rings) # assert_almost_equal(r.geom.area, 100 * 100 / 2 - 100, -3) def test_simple_polygon_w_hole(self): w1 = Way(1, {}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] w2 = Way(2, {}, [5, 6, 7, 8, 5]) w2.coords = [(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)] r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) eq_(len(rings), 2) eq_(rings[0].geom.area, 100) eq_(rings[1].geom.area, 36) builder.build_relation_geometry(rings) eq_(r.geom.area, 100-36) def test_polygon_w_multiple_holes(self): w1 = Way(1, {'landusage': 'forest'}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] w2 = Way(2, {'water': 'basin'}, [1, 2, 3, 4, 1]) w2.coords = [(1, 1), (2, 1), (2, 2), (1, 2), (1, 1)] w3 = Way(3, {'landusage': 'scrub'}, [1, 2, 3, 4, 1]) w3.coords = [(3, 3), (4, 3), (4, 4), (3, 4), (3, 3)] r = Relation(1, {'landusage': 'forest'}, [ (1, 'way', 'outer'), (2, 'way', 'inner'), (3, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2, w3]) eq_(len(rings), 3) eq_(rings[0].geom.area, 100) eq_(rings[1].geom.area, 1) eq_(rings[2].geom.area, 1) builder.build_relation_geometry(rings) eq_(rings[0].inserted, True) eq_(rings[1].inserted, False) eq_(rings[2].inserted, False) eq_(r.geom.area, 100-1-1) def test_polygon_w_nested_holes(self): w1 = Way(1, {'landusage': 'forest'}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] w2 = Way(2, {'landusage': 'scrub'}, [1, 2, 3, 4, 1]) w2.coords = [(1, 1), (9, 1), (9, 9), (1, 9), (1, 1)] w3 = Way(3, {}, [5, 6, 7, 8, 5]) # with no tags w3.coords = [(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)] w4 = Way(4, {'landusage': 'scrub'}, [9, 10, 11, 12, 9]) w4.coords = [(3, 3), (7, 3), (7, 7), (3, 7), (3, 3)] w5 = Way(5, {'landusage': 'forest'}, [9, 10, 11, 12, 9]) w5.coords = [(4, 4), (6, 4), (6, 6), (4, 6), (4, 4)] r = Relation(1, {'landusage': 'forest'}, [ (1, 'way', 'outer'), (2, 'way', 'inner'), (3, 'way', 'inner'), (4, 'way', 'inner'), (5, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2, w3, w4, w5]) eq_(len(rings), 5) eq_(rings[0].geom.area, 100) eq_(rings[1].geom.area, 64) eq_(rings[2].geom.area, 36) eq_(rings[3].geom.area, 16) eq_(rings[4].geom.area, 4) builder.build_relation_geometry(rings) eq_(rings[0].inserted, True) eq_(rings[1].inserted, False) eq_(rings[2].inserted, True) eq_(rings[3].inserted, False) eq_(rings[4].inserted, True) eq_(r.geom.area, 100-64+36-16+4) def test_polygon_w_touching_holes(self): w1 = Way(1, {'landusage': 'forest'}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] w2 = Way(2, {'landusage': 'scrub'}, [1, 2, 3, 4, 1]) w2.coords = [(1, 1), (5, 1), (5, 9), (1, 9), (1, 1)] w3 = Way(3, {'water': 'basin'}, [1, 2, 3, 4, 1]) w3.coords = [(5, 1), (9, 1), (9, 9), (5, 9), (5, 1)] r = Relation(1, {'landusage': 'forest'}, [ (1, 'way', 'outer'), (2, 'way', 'inner'), (3, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2, w3]) eq_(len(rings), 3) eq_(rings[0].geom.area, 100) eq_(rings[1].geom.area, 32) eq_(rings[2].geom.area, 32) builder.build_relation_geometry(rings) eq_(rings[0].inserted, True) eq_(rings[1].inserted, False) eq_(rings[2].inserted, False) eq_(r.geom.area, 100-64) def test_touching_polygons_w_hole(self): w1 = Way(1, {'water': 'riverbank'}, [1, 2, 3, 4, 1]) w1.coords = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] w2 = Way(2, {'water': 'riverbank'}, [2, 5, 6, 3, 2]) w2.coords = [(10, 0), (30, 0), (30, 10), (10, 10), (10, 0)] w3 = Way(3, {'landusage': 'forest'}, [7, 8, 9, 10, 7]) w3.coords = [(2, 2), (8, 2), (8, 8), (2, 8), (2, 2)] r = Relation(1, {'water': 'riverbank'}, [ (1, 'way', 'outer'), (2, 'way', 'outer'), (3, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2, w3]) eq_(len(rings), 3) eq_(rings[0].geom.area, 100) eq_(rings[1].geom.area, 200) eq_(rings[2].geom.area, 36) builder.build_relation_geometry(rings) eq_(rings[0].inserted, True) eq_(rings[1].inserted, True) eq_(rings[2].inserted, False) eq_(r.geom.area, 100+200-36) def test_simple_polygon_from_two_lines(self): w1 = Way(1, {}, [1, 2, 3]) w1.coords = [(0, 0), (10, 0), (10, 10)] w2 = Way(2, {}, [3, 4, 1]) w2.coords = [(10, 10), (0, 10), (0, 0)] r = Relation(1, {}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) eq_(len(rings), 1) eq_(rings[0].geom.area, 100) builder.build_relation_geometry(rings) eq_(r.geom.area, 100) def test_inserted_ways_different_tags(self): w1 = Way(1, {'landusage': 'forest'}, [1, 2, 3]) w1.coords = [(0, 0), (10, 0), (10, 10)] w2 = Way(2, {'highway': 'secondary'}, [3, 4, 1]) w2.coords = [(10, 10), (0, 10), (0, 0)] r = Relation(1, {'landusage': 'forest'}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) builder.build_relation_geometry(rings) eq_(w1.inserted, True) eq_(w2.inserted, False) def test_inserted_multiple_tags(self): w1 = Way(1, {'landusage': 'forest', 'highway': 'secondary'}, [1, 2, 3]) w1.coords = [(0, 0), (10, 0), (10, 10)] w2 = Way(2, {'highway': 'secondary'}, [3, 4, 1]) w2.coords = [(10, 10), (0, 10), (0, 0)] r = Relation(1, {'landusage': 'forest'}, [(1, 'way', 'outer'), (2, 'way', 'inner')]) builder = self.relation_builder(r, None, None) rings = builder.build_rings([w1, w2]) builder.build_relation_geometry(rings) eq_(w1.inserted, False) # also highway=secondary eq_(w2.inserted, False) class TestUnionRelationBuilder(RelationBuilderTestBase): relation_builder = UnionRelationBuilder class TestContainsRelationBuilder(RelationBuilderTestBase): relation_builder = ContainsRelationBuilder def test_merge_rings(): w1 = Way(1, {}, [1, 2, 3]) w1.coords = [(0, 0), (10, 0), (10, 10)] r1 = Ring(w1) w2 = Way(2, {}, [3, 4, 1]) w2.coords = [(10, 10), (0, 10), (0, 0)] r2 = Ring(w2) rings = merge_rings([r1, r2]) eq_(len(rings), 1) r = rings[0] eq_(r.is_closed(), True) # eq_(r.ways, [w1, w2]) def test_merge_rings_reverse_endpoint(): w1 = Way(1, {'name': 'foo'}, [1, 2, 3, 4]) w1.coords = [] r1 = Ring(w1) w2 = Way(2, {'building': 'true'}, [6, 5, 4]) w2.coords = [] r2 = Ring(w2) w3 = Way(3, {}, [1, 7, 6]) w3.coords = [] r3 = Ring(w3) rings = merge_rings([r1, r2, r3]) eq_(len(rings), 1) r = rings[0] eq_(r.tags, {'name': 'foo', 'building': 'true'}) eq_(r.is_closed(), True) # eq_(r.ways, [w1, w2, w3]) class W(Way): # way without coords coords = [] from imposm.merge import permutations def test_merge_rings_permutations(): """ Test all possible permutations of 4 ring segments. """ for i in range(16): # test each segment in both directions f1 = i & 1 == 0 f2 = i & 2 == 0 f3 = i & 4 == 0 f4 = i & 8 == 0 for i1, i2, i3, i4 in permutations([0, 1, 2, 3]): ways = [ W(1, {}, [1, 2, 3, 4] if f1 else [4, 3, 2, 1]), W(2, {}, [4, 5, 6, 7] if f2 else [7, 6, 5, 4]), W(3, {}, [7, 8, 9, 10] if f3 else [10, 9, 8, 7]), W(4, {}, [10, 11, 12, 1] if f4 else [1, 12, 11, 10]), ] ways = [ways[i1], ways[i2], ways[i3], ways[i4]] rings = [Ring(w) for w in ways] merged_rings = merge_rings(rings) eq_(len(merged_rings), 1) r = merged_rings[0] eq_(r.is_closed(), True, (ways, r.refs)) eq_(set(r.ways), set(ways)) # check order of refs prev_x = r.refs[0] for x in r.refs[1:]: if not abs(prev_x - x) == 1: assert ( (prev_x == 1 and x == 12) or (prev_x == 12 and x == 1) ), 'not in order %r' % r.refs prev_x = ximposm-2.6.0/imposm/test/test_tag_mapper.py0000644000076500000240000001757512454213472021002 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import imposm from imposm.mapping import TagMapper, LineStrings from nose.tools import eq_ 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 def eq_mapping(actual_mappings, expected_mappings): assert len(actual_mappings) == len(expected_mappings), '%s != %s' % (actual_mappings, expected_mappings) actual_mappings = [(tags, tuple(m.name for m in mappings)) for tags, mappings in actual_mappings] actual_mappings.sort() expected_mappings.sort() eq_(actual_mappings, expected_mappings) imposm-2.6.0/imposm/util/0000755000076500000240000000000012454222732015230 5ustar oltstaff00000000000000imposm-2.6.0/imposm/util/__init__.py0000644000076500000240000001560712147670251017354 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import sys import time import datetime import mmap import multiprocessing from multiprocessing import JoinableQueue from Queue import Empty import logging log = logging.getLogger(__name__) try: from setproctitle import setproctitle setproctitle except ImportError: setproctitle = lambda x: None class Timer(object): def __init__(self, title, logger): self.title = title self.logger = logger self.start_time = time.time() def stop(self): seconds = time.time() - self.start_time self.logger.message('%s took %s' % (self.title, format_total_time(seconds))) class ParserProgress(multiprocessing.Process): log_every_seconds = 0.2 def __init__(self): self.queue = multiprocessing.Queue() multiprocessing.Process.__init__(self) def run(self): last_log = time.time() counters = {'coords': 0, 'nodes':0, 'ways':0, 'relations':0} while True: log_statement = self.queue.get() if log_statement is None: break log_type, incr = log_statement counters[log_type] += incr if time.time() - last_log > self.log_every_seconds: last_log = time.time() self.print_log(counters) @staticmethod def message(msg): print >>sys.stderr, "[%s] %s" % (timestamp(), msg) sys.stderr.flush() def print_log(self, counters): print >>sys.stderr, "[%s] coords: %dk nodes: %dk ways: %dk relations: %dk\r" % ( timestamp(), int(counters['coords']/1000), int(counters['nodes']/1000), int(counters['ways']/1000), int(counters['relations']/1000) ), sys.stderr.flush() def log(self, log_type, incr): self.queue.put((log_type, incr)) def stop(self): sys.stderr.write('\n') sys.stderr.flush() self.queue.put(None) class QuietParserProgress(ParserProgress): log_every_seconds = 60 class ProgressLog(object): log_every_seconds = 0.2 def __init__(self, title=None, total=None): self.count = 0 self.total = total self._total = '/%dk' % (total/1000) if total else '' self.title = title self.start_time = time.time() self.last_log = time.time() self.print_log() @staticmethod def message(msg): print >>sys.stderr, "[%s] %s" % (timestamp(), msg) sys.stderr.flush() def log(self, value=None, step=1): before = self.count//1000 if value: self.count = value else: self.count += step if self.count//1000 > before: self.print_log() def print_log(self): if time.time() - self.last_log > self.log_every_seconds: self.last_log = time.time() print >>sys.stderr, "[%s] %s: %dk%s\r" % ( timestamp(), self.title, int(self.count/1000), self._total, ), sys.stderr.flush() def stop(self): print >>sys.stderr seconds = time.time() - self.start_time total_time = format_total_time(seconds) print >>sys.stderr, "[%s] %s: total time %s for %d (%d/s)" % ( timestamp(), self.title, total_time, self.count, self.count/seconds) sys.stderr.flush() class QuietProgressLog(ProgressLog): log_every_seconds = 60 def timestamp(): return datetime.datetime.now().strftime('%H:%M:%S') def format_total_time(seconds): h, m, s = seconds_to_hms(seconds) res = '%-02ds' % s if h or m: res = '%-02dm ' % m + res if h: res = '%-02dh ' % h + res return res def seconds_to_hms(seconds): h, s = divmod(seconds, 60*60) m, s = divmod(s, 60) return h, m, s class NullLog(object): def log_node(self): pass node = log_node def log_way(self): pass way = log_way def log_relation(self): pass relation = log_relation class MMapReader(object): def __init__(self, m, size): self.m = m self.m.seek(0) self.size = size def read(self, size=None): if size is None: size = self.size - self.m.tell() else: size = min(self.size - self.m.tell(), size) return self.m.read(size) def readline(self): cur_pos = self.m.tell() if cur_pos >= self.size: return nl_pos = self.m.find('\n') self.m.seek(cur_pos) return self.m.read(nl_pos-cur_pos) def seek(self, n): self.m.seek(n) class MMapPool(object): def __init__(self, n, mmap_size): self.n = n self.mmap_size = mmap_size self.pool = [mmap.mmap(-1, mmap_size) for _ in range(n)] self.free_mmaps = set(range(n)) self.free_queue = JoinableQueue() def new(self): if not self.free_mmaps: self.free_mmaps.add(self.free_queue.get()) self.free_queue.task_done() while True: try: self.free_mmaps.add(self.free_queue.get_nowait()) self.free_queue.task_done() except Empty: break mmap_idx = self.free_mmaps.pop() return mmap_idx, self.pool[mmap_idx] def join(self): while len(self.free_mmaps) < self.n: self.free_mmaps.add(self.free_queue.get()) self.free_queue.task_done() def get(self, idx): return self.pool[idx] def free(self, idx): self.free_queue.put(idx) def create_pool(creator, size): pool = [] for i in xrange(size): proc = creator() proc.start() pool.append(proc) return pool def shutdown_pool(procs, queue=None, sentinel=None): if queue: for _ in range(len(procs)): queue.put(sentinel) for p in procs: p.join(timeout=10*60) # 10 min if p.is_alive(): log.warn('could not join process %r, terminating process', p) p.terminate() def estimate_records(files): records = 0 for f in files: fsize = os.path.getsize(f) if f.endswith('.bz2'): fsize *= 11 # observed bzip2 compression factor on osm data if f.endswith('.pbf'): fsize *= 15 # observed pbf compression factor on osm data records += fsize/200 return int(records) imposm-2.6.0/imposm/util/geom.py0000644000076500000240000001147212236167777016555 0ustar oltstaff00000000000000# This file is part of the MapProxy project. # Copyright (C) 2010 Omniscale # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import division, with_statement import codecs import os from functools import partial import logging log = logging.getLogger(__name__) try: import shapely.wkt import shapely.geometry import shapely.ops import shapely.prepared geom_support = True except ImportError: geom_support = False def require_geom_support(): if not geom_support: raise ImportError('Shapely required for geometry support') def load_datasource(datasource, where=None): """ Loads polygons from WKT text files or OGR datasources. Returns a list of Shapely Polygons. """ # check if it is a wkt file if os.path.exists(os.path.abspath(datasource)): with open(os.path.abspath(datasource), 'r') as fp: data = fp.read(50) if data.lower().lstrip().startswith(('polygon', 'multipolygon')): return load_polygons(datasource) # otherwise pass to OGR return load_ogr_datasource(datasource, where=where) def load_ogr_datasource(datasource, where=None): """ Loads polygons from any OGR datasource. Returns a list of Shapely Polygons. """ from imposm.util.ogr import OGRShapeReader polygons = [] for wkt in OGRShapeReader(datasource).wkts(where): geom = shapely.wkt.loads(wkt) if geom.type == 'Polygon': polygons.append(geom) elif geom.type == 'MultiPolygon': for p in geom: polygons.append(p) else: log.info('skipping %s geometry from %s: not a Polygon/MultiPolygon', geom.type, datasource) return polygons def load_polygons(geom_files): """ Loads WKT polygons from one or more text files. Returns a Shapely MultiPolygon with the loaded geometries. """ polygons = [] if isinstance(geom_files, basestring): geom_files = [geom_files] for geom_file in geom_files: # open with utf-8-sig encoding to get rid of UTF8 BOM from MS Notepad with codecs.open(geom_file, encoding='utf-8-sig') as f: polygons.extend(load_polygon_lines(f, source=geom_files)) return polygons def load_polygon_lines(line_iter, source=''): polygons = [] for line in line_iter: if not line.strip(): continue geom = shapely.wkt.loads(line) if geom.type == 'Polygon': polygons.append(geom) elif geom.type == 'MultiPolygon': for p in geom: polygons.append(p) else: log.info('ignoring non-polygon geometry (%s) from %s', geom.type, source) return polygons def build_multipolygon(polygons, simplify=False): if polygons: mp = shapely.geometry.MultiPolygon(polygons) if simplify: mp = simplify_geom(mp) else: mp = shapely.geometry.Polygon() return mp.bounds, mp def simplify_geom(geom): bounds = geom.bounds w, h = bounds[2] - bounds[0], bounds[3] - bounds[1] tolerance = min((w/1e6, h/1e6)) return geom.simplify(tolerance, preserve_topology=True) def bbox_polygon(bbox): """ Create Polygon that covers the given bbox. """ return shapely.geometry.Polygon(( (bbox[0], bbox[1]), (bbox[2], bbox[1]), (bbox[2], bbox[3]), (bbox[0], bbox[3]), )) def transform_geometry(from_srs, to_srs, geometry): transf = partial(transform_xy, from_srs, to_srs) if geometry.type == 'Polygon': return transform_polygon(transf, geometry) if geometry.type == 'MultiPolygon': return transform_multipolygon(transf, geometry) raise ValueError('cannot transform %s' % geometry.type) def transform_polygon(transf, polygon): ext = transf(polygon.exterior.xy) ints = [transf(ring.xy) for ring in polygon.interiors] return shapely.geometry.Polygon(ext, ints) def transform_multipolygon(transf, multipolygon): transformed_polygons = [] for polygon in multipolygon: transformed_polygons.append(transform_polygon(transf, polygon)) return shapely.geometry.MultiPolygon(transformed_polygons) def transform_xy(from_srs, to_srs, xy): return list(from_srs.transform_to(to_srs, zip(*xy))) imposm-2.6.0/imposm/util/lib.py0000644000076500000240000000630712147670251016360 0ustar oltstaff00000000000000# This file is part of the MapProxy project. # Copyright (C) 2010 Omniscale # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ ctypes utilities. """ import sys import os from ctypes import CDLL from ctypes.util import find_library as _find_library default_locations = dict( darwin=dict( paths = ['/opt/local/lib'], exts = ['.dylib'], ), win32=dict( paths = [os.path.dirname(os.__file__) + '/../../../DLLs'], exts = ['.dll'] ), other=dict( paths = [], # MAPPROXY_LIB_PATH will add paths here exts = ['.so'] ), ) # TODO does this work for imposm too? additional_lib_path = os.environ.get('MAPPROXY_LIB_PATH') if additional_lib_path: additional_lib_path = additional_lib_path.split(os.pathsep) additional_lib_path.reverse() for locs in default_locations.values(): for path in additional_lib_path: locs['paths'].insert(0, path) def load_library(lib_names, locations_conf=default_locations): """ Load the `lib_name` library with ctypes. If ctypes.util.find_library does not find the library, different path and filename extensions will be tried. Retruns the loaded library or None. """ if isinstance(lib_names, basestring): lib_names = [lib_names] for lib_name in lib_names: lib = load_library_(lib_name, locations_conf) if lib is not None: return lib def load_library_(lib_name, locations_conf=default_locations): lib_path = find_library(lib_name) if lib_path: return CDLL(lib_path) if sys.platform in locations_conf: paths = locations_conf[sys.platform]['paths'] exts = locations_conf[sys.platform]['exts'] lib_path = find_library(lib_name, paths, exts) else: paths = locations_conf['other']['paths'] exts = locations_conf['other']['exts'] lib_path = find_library(lib_name, paths, exts) if lib_path: return CDLL(lib_path) def find_library(lib_name, paths=None, exts=None): """ Search for library in all permutations of `paths` and `exts`. If nothing is found None is returned. """ if not paths or not exts: lib = _find_library(lib_name) if lib is None and lib_name.startswith('lib'): lib = _find_library(lib_name[3:]) return lib for lib_name in [lib_name] + ([lib_name[3:]] if lib_name.startswith('lib') else []): for path in paths: for ext in exts: lib_path = os.path.join(path, lib_name + ext) if os.path.exists(lib_path): return lib_path return None if __name__ == '__main__': print load_library(sys.argv[1]) imposm-2.6.0/imposm/util/ogr.py0000644000076500000240000001030012147670251016365 0ustar oltstaff00000000000000# This file is part of the MapProxy project. # Copyright (C) 2010 Omniscale # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from imposm.util.lib import load_library import ctypes from ctypes import c_void_p, c_char_p, c_int def init_libgdal(): libgdal = load_library(['libgdal', 'libgdal1']) if not libgdal: return libgdal.OGROpen.argtypes = [c_char_p, c_int, c_void_p] libgdal.OGROpen.restype = c_void_p libgdal.CPLGetLastErrorMsg.argtypes = [] libgdal.CPLGetLastErrorMsg.restype = c_char_p libgdal.OGR_DS_GetLayer.argtypes = [c_void_p, c_int] libgdal.OGR_DS_GetLayer.restype = c_void_p libgdal.OGR_FD_GetName.argtypes = [c_void_p] libgdal.OGR_FD_GetName.restype = c_char_p libgdal.OGR_L_GetLayerDefn.argtypes = [c_void_p] libgdal.OGR_L_GetLayerDefn.restype = c_void_p libgdal.OGR_DS_Destroy.argtypes = [c_void_p] libgdal.OGR_DS_ExecuteSQL.argtypes = [c_void_p, c_char_p, c_void_p, c_char_p] libgdal.OGR_DS_ExecuteSQL.restype = c_void_p libgdal.OGR_DS_ReleaseResultSet.argtypes = [c_void_p, c_void_p] libgdal.OGR_L_ResetReading.argtypes = [c_void_p] libgdal.OGR_L_GetNextFeature.argtypes = [c_void_p] libgdal.OGR_L_GetNextFeature.restype = c_void_p libgdal.OGR_F_Destroy.argtypes = [c_void_p] libgdal.OGR_F_GetGeometryRef.argtypes = [c_void_p] libgdal.OGR_F_GetGeometryRef.restype = c_void_p libgdal.OGR_G_ExportToWkt.argtypes = [c_void_p, ctypes.POINTER(c_char_p)] libgdal.OGR_G_ExportToWkt.restype = c_void_p libgdal.VSIFree.argtypes = [c_void_p] libgdal.OGRRegisterAll() return libgdal libgdal = init_libgdal() class OGRShapeReaderError(Exception): pass class OGRShapeReader(object): def __init__(self, datasource): self.datasource = datasource self.opened = False self._ds = None def open(self): if self.opened: return self._ds = libgdal.OGROpen(self.datasource, False, None) if self._ds is None: msg = libgdal.CPLGetLastErrorMsg() if not msg: msg = 'failed to open %s' % self.datasource raise OGRShapeReaderError(msg) def wkts(self, where=None): if not self.opened: self.open() if where: if not where.lower().startswith('select'): layer = libgdal.OGR_DS_GetLayer(self._ds, 0) layer_def = libgdal.OGR_L_GetLayerDefn(layer) name = libgdal.OGR_FD_GetName(layer_def) where = 'select * from %s where %s' % (name, where) layer = libgdal.OGR_DS_ExecuteSQL(self._ds, where, None, None) else: layer = libgdal.OGR_DS_GetLayer(self._ds, 0) if layer is None: msg = libgdal.CPLGetLastErrorMsg() raise OGRShapeReaderError(msg) libgdal.OGR_L_ResetReading(layer) while True: feature = libgdal.OGR_L_GetNextFeature(layer) if feature is None: break geom = libgdal.OGR_F_GetGeometryRef(feature) res = c_char_p() libgdal.OGR_G_ExportToWkt(geom, ctypes.byref(res)) yield res.value libgdal.VSIFree(res) libgdal.OGR_F_Destroy(feature) if where: libgdal.OGR_DS_ReleaseResultSet(self._ds, layer) def close(self): if self.opened: libgdal.OGR_DS_Destroy(self._ds) self.opened = False def __del__(self): self.close() if __name__ == '__main__': import sys reader = OGRShapeReader(sys.argv[1]) where = None if len(sys.argv) == 3: where = sys.argv[2] for wkt in reader.wkts(where): print wktimposm-2.6.0/imposm/version.py0000644000076500000240000000115612454213025016310 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. __version__ = '2.6.0' imposm-2.6.0/imposm/writer.py0000644000076500000240000000701312147670245016147 0ustar oltstaff00000000000000# Copyright 2011 Omniscale (http://omniscale.com) # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from multiprocessing import Process, JoinableQueue from imposm.dbimporter import NodeProcessTuple, WayProcessTuple, RelationProcessTuple from imposm.dbimporter import NodeProcessDict, WayProcessDict, RelationProcessDict from imposm.util import create_pool, shutdown_pool import_processes = { 'tuple': { 'node': NodeProcessTuple, 'way': WayProcessTuple, 'relation': RelationProcessTuple, }, 'dict': { 'node': NodeProcessDict, 'way': WayProcessDict, 'relation': RelationProcessDict, } } class ImposmWriter(object): def __init__(self, mapping, db, cache, pool_size=2, logger=None, dry_run=False): self.mapping = mapping self.db = db self.mapper = mapping self.cache = cache self.pool_size = pool_size self.logger = logger self.dry_run = dry_run def _write_elem(self, proc, elem_cache, log, pool_size, proc_args=[]): queue = JoinableQueue(16) importer = lambda: proc(queue, self.db, self.mapper, self.cache, self.dry_run, *proc_args) pool = create_pool(importer, pool_size) data = [] for i, elem in enumerate(elem_cache): if elem.tags: data.append(elem) if len(data) >= 128: queue.put(data) log.log(i) data = [] queue.put(data) shutdown_pool(pool, queue) log.stop() self.cache.close_all() def relations(self): self.cache.remove_inserted_way_cache() cache = self.cache.relations_cache() log = self.logger('relations', len(cache)) inserted_way_queue = JoinableQueue() way_marker = WayMarkerProcess(inserted_way_queue, self.cache, self.logger) way_marker.start() self._write_elem(import_processes[self.db.insert_data_format]['relation'], cache, log, self.pool_size, [inserted_way_queue]) inserted_way_queue.put(None) way_marker.join() def ways(self): cache = self.cache.ways_cache() log = self.logger('ways', len(cache)) self._write_elem(import_processes[self.db.insert_data_format]['way'], cache, log, self.pool_size) self.cache.remove_inserted_way_cache() def nodes(self): cache = self.cache.nodes_cache() log = self.logger('nodes', len(cache)) self._write_elem(import_processes[self.db.insert_data_format]['node'], cache, log, self.pool_size) class WayMarkerProcess(Process): def __init__(self, queue, cache, logger): Process.__init__(self) self.daemon = True self.queue = queue self.cache = cache self.logger = logger def run(self): inserted_ways = self.cache.inserted_ways_cache('w') while True: osmid = self.queue.get() if osmid is None: break inserted_ways.put(osmid) inserted_ways.close() imposm-2.6.0/internal.proto0000644000076500000240000000040112454176011015641 0ustar oltstaff00000000000000package imposm.cache.internal; message DeltaCoords { repeated sint64 ids = 1 [packed = true]; repeated sint64 lats = 2 [packed = true]; repeated sint64 lons = 3 [packed = true]; } message DeltaList { repeated sint64 ids = 1 [packed = true]; } imposm-2.6.0/LICENSE0000644000076500000240000002613611766043214013765 0ustar oltstaff00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. imposm-2.6.0/MANIFEST.in0000644000076500000240000000036012147670245014511 0ustar oltstaff00000000000000include setup.py include README.rst include LICENSE include CHANGES include imposm/900913.sql include imposm/cache/tc.c include imposm/cache/tc.pyx include internal.proto include imposm/cache/internal.cc exclude imposm/cache/internal.pb.cc imposm-2.6.0/PKG-INFO0000644000076500000240000001177212454222732014054 0ustar oltstaff00000000000000Metadata-Version: 1.1 Name: imposm Version: 2.6.0 Summary: OpenStreetMap importer for PostGIS. Home-page: http://imposm.org/ Author: Oliver Tonnhofer Author-email: olt@omniscale.de License: Apache Software License 2.0 Description: Imposm is an importer for OpenStreetMap data. It reads XML and PBF files and can import the data into PostgreSQL/PostGIS databases. It is designed to create databases that are optimized for rendering/WMS services. It is developed and supported by `Omniscale `_, runs on Linux or Mac OS X and is released as open source under the `Apache Software License 2.0 `_. See http://imposm.org/ for more information. Changelog --------- 2.6.0 2015-01-10 ~~~~~~~~~~~~~~~~ - improve load performance of large limit-to geometries - check connection before reading and fail if unable to connect - new BoundaryPolygons mapping class that keeps inserted ways - quote column names when generalizing table - only skip import of polygons if way was inserted as multipolygon - only look for tables/views/indexes with schema=public when rotating tables - updated generated code for internal cache - minor fixes 2.5.0 2012-12-06 ~~~~~~~~~~~~~~~~ - PostGIS 2 support - new --limit-to option to limit imports to polygons - added --quiet option that only logs progress once per minute - add StringIndex and Index mappings for PostgreSQL - always drop tables _and_ views with same name before creating new table/view. allows to change mappings from views to tables and vice versa. - internal refactoring to make support for non SQL databases easier 2.4.0 2012-03-30 ~~~~~~~~~~~~~~~~ - new Class and Type field types - add support to disable automatic ``type`` column - new --connection option - support for PostGIS Trigram indices - do not try to simplify empty geometries - limit progress logging to 5 times per second - use SERIAL as primary key to support multiple features with the same OSM ID - new optional splitting of long line strings - use BIGINT for OSM ID in Postgres to support 64bit OSM IDs 2.3.2 2011-09-05 ~~~~~~~~~~~~~~~~ - fixed --table-prefix - add --debug option for more verbose output - fixed way merging - fixed default_name_fields for UnionViews - improved (contains) relation builder 2.3.1 2011-07-05 ~~~~~~~~~~~~~~~~ - DROP views instead of REPLACE to prevent errors when columns changed 2.3.0 2011-07-05 ~~~~~~~~~~~~~~~~ - new PseudoArea field type - new Name and LocalizedName field type - update SRS in GeneralizedTables and UnionTables - new waterareas_gen0|1 in default style - new area field in landusages table - new meter_to_mapunit function to use same mapping for EPSG:4326 and projected SRS 2.2.0 2011-06-01 ~~~~~~~~~~~~~~~~ - support for Shapely speedups (>=1.2.10) - new --port option for PostgreSQL port - reduced size of nodes cache by ~40% - store inserted ways in extra cache - support for relations type=boundary - new faster relation builder that supports relations with >1000 rings - set import options in mapping file - import_partial_relations=True/False - relation_builder=contains(new)/union(old) - imposm_multipolygon_report=60(seconds) - imposm_multipolygon_max_ring=0 2.1.3 2011-04-19 ~~~~~~~~~~~~~~~~ - support for colons and other special chars in field and table names (e.g. de:name) 2.1.2 2011-04-13 ~~~~~~~~~~~~~~~~ - make it work on 32bit systems 2.1.1 2011-04-12 ~~~~~~~~~~~~~~~~ - new ``--proj`` option to change DB projection from EPSG:900913 - abort if there are existing cache files - new ``--merge-cache`` and ``--overwrite-cache`` options 2.1.0 2011-03-29 ~~~~~~~~~~~~~~~~ - first open source release Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: License :: OSI Approved :: Apache Software License Classifier: Operating System :: OS Independent Classifier: Programming Language :: C Classifier: Programming Language :: C++ Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Topic :: Scientific/Engineering :: GIS imposm-2.6.0/README.rst0000644000076500000240000000074212147670245014446 0ustar oltstaff00000000000000Imposm is an importer for OpenStreetMap data. It reads XML and PBF files and can import the data into PostgreSQL/PostGIS databases. It is designed to create databases that are optimized for rendering/WMS services. It is developed and supported by `Omniscale `_, runs on Linux or Mac OS X and is released as open source under the `Apache Software License 2.0 `_. See http://imposm.org/ for more information. imposm-2.6.0/setup.cfg0000644000076500000240000000021112454222732014562 0ustar oltstaff00000000000000[nosetests] cover-erase = 1 verbosity = 2 doctest-tests = 1 with-doctest = 1 [egg_info] tag_date = 0 tag_build = tag_svn_revision = 0 imposm-2.6.0/setup.py0000644000076500000240000001054012147670245014466 0ustar oltstaff00000000000000import os import errno import subprocess import sys from setuptools import setup, find_packages from setuptools.extension import Extension from setuptools.command.build_ext import build_ext from distutils.errors import DistutilsPlatformError install_requires = [ 'imposm.parser', 'psycopg2', 'Shapely', ] if sys.version_info < (2, 6): install_requires.append('multiprocessing') class build_ext_with_cython(build_ext): def generate_c_file(self): try: if (os.path.exists('imposm/cache/tc.c') and os.path.getmtime('imposm/cache/tc.pyx') < os.path.getmtime('imposm/cache/tc.c')): print 'imposm/cache/tc.c up to date' return print 'creating imposm/cache/tc.c' proc = subprocess.Popen( ['cython', 'imposm/cache/tc.pyx'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) except OSError, ex: if ex.errno == errno.ENOENT: print "Could not find cython command." raise DistutilsPlatformError("Failed to generate " "C files with cython.") else: raise out = proc.communicate()[0] result = proc.wait() if result != 0: print "Error during C files generation with cython:" print out raise DistutilsPlatformError("Failed to generate " "C files with cython.") def generate_protoc(self): try: if (os.path.exists('imposm/cache/internal.pb.cc') and os.path.getmtime('internal.proto') < os.path.getmtime('imposm/cache/internal.pb.cc')): print 'imposm/cache/internal.pb.cc up to date' return print 'creating protofiles' proc = subprocess.Popen( ['protoc', '--cpp_out', 'imposm/cache/', 'internal.proto'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) except OSError, ex: if ex.errno == errno.ENOENT: print ("Could not find protoc command. Make sure protobuf is " "installed and your PATH environment is set.") raise DistutilsPlatformError("Failed to generate protbuf " "CPP files with protoc.") else: raise out = proc.communicate()[0] result = proc.wait() if result != 0: print "Error during protbuf files generation with protoc:" print out raise DistutilsPlatformError("Failed to generate protbuf " "CPP files with protoc.") def run(self): self.generate_protoc() try: self.generate_c_file() except DistutilsPlatformError: if os.path.exists('imposm/cache/tc.c'): print 'Found existing C file. Ignoring previous error.' else: raise build_ext.run(self) import imposm.version version = imposm.version.__version__ setup( name = "imposm", version = version, description='OpenStreetMap importer for PostGIS.', long_description=open('README.rst').read() + open('CHANGES').read(), author = "Oliver Tonnhofer", author_email = "olt@omniscale.de", url='http://imposm.org/', license='Apache Software License 2.0', packages=find_packages(), namespace_packages = ['imposm'], include_package_data=True, package_data = {'': ['*.xml']}, install_requires=install_requires, classifiers=[ "Development Status :: 4 - Beta", "License :: OSI Approved :: Apache Software License", "Operating System :: OS Independent", "Programming Language :: C", "Programming Language :: C++", "Programming Language :: Python :: 2.5", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Topic :: Scientific/Engineering :: GIS", ], ext_modules=[ Extension("imposm.cache.tc", ["imposm/cache/tc.c"], libraries = ["tokyocabinet"]), Extension("imposm.cache.internal", ["imposm/cache/internal.cc", "imposm/cache/internal.pb.cc"], libraries = ["protobuf"]), ], entry_points = { 'console_scripts': [ 'imposm = imposm.app:main', 'imposm-psqldb = imposm.psqldb:main', ], }, cmdclass={'build_ext':build_ext_with_cython}, )