def resolve(code):
"""
Resolve an EPSG code to an object
"""
global _registry
try:
return _registry[code]
except TypeError:
pass
except KeyError:
return None
path = os.path.join(os.path.dirname(__file__), os.path.pardir, os.path.pardir, 'data', 'epsg-registry.sqlite')
engine = create_engine('sqlite:///%s' % path)
_registry = Registry(engine)
return _registry.get(code, None)
def main():
"""
Update the local registry
"""
parser = argparse.ArgumentParser(
description='Update the EPSG SQLite database from the online registry.'
)
parser.add_argument('file',
metavar='FILE',
nargs=1,
help='The SQLite database file to update')
args = parser.parse_args()
filename = abspath(args.file[0])
try:
engine = create_engine('sqlite:///%s' % filename)
# create an empty Registry if it is not already populated
registry = Registry(engine, loader=False)
registry.init(loader=False) # re-initialise the database
loader = registry.getLoader()
registry.update(loader)
del registry
del engine
except KeyboardInterrupt:
print >> stderr, "\nInterrupted!"
def main():
"""
Update the local registry
"""
parser = argparse.ArgumentParser(description='Update the EPSG SQLite database from the online registry.')
parser.add_argument('file', metavar='FILE', nargs=1,
help='The SQLite database file to update')
args = parser.parse_args()
filename = abspath(args.file[0])
try:
engine = create_engine('sqlite:///%s' % filename)
# create an empty Registry if it is not already populated
registry = Registry(engine, loader=False)
registry.init(loader=False) # re-initialise the database
loader = registry.getLoader()
registry.update(loader)
del registry
del engine
except KeyboardInterrupt:
print >> stderr, "\nInterrupted!"
from __future__ import print_function
import os
from sqlalchemy import create_engine
from epsg import Registry, schema
db = "epsg-registry-cache.db"
if os.path.exists(db):
engine = create_engine("sqlite:///epsg-registry-cache.db")
registry = Registry(engine)
else:
engine = create_engine("sqlite:///epsg-registry-cache.db")
registry = Registry(engine)
print("Downloading EPSG registry, this takes a while...")
registry.init()
west, south, east, north = -61.83, 11.97, -61.57, 12.26
crss = (
registry.session.query(schema.ProjectedCRS)
.join(schema.ProjectedCRS.domainOfValidity)
.filter(schema.AreaOfUse.westBoundLongitude <= west)
.filter(schema.AreaOfUse.southBoundLatitude <= south)
.filter(schema.AreaOfUse.eastBoundLongitude >= east)
.filter(schema.AreaOfUse.northBoundLatitude >= north)
.all()
)
for crs in crss:
print("-------------------------------------------------------------")
print(crs.name, "({})".format(crs.identifier))
print(crs.scope)
def setUp(self):
self.registry = Registry(loader=False)
xml = load.XML.FromFile(getTestFile())
self.loader = load.XMLLoader(xml)
self.loader.load()
def testUpdate(self):
registry2 = Registry(loader=False)
registry2.update(self.registry)
self.assertEqual(len(self.registry), len(registry2))
def setUp(self):
xml = load.XML.FromFile(getTestFile())
loader = load.XMLLoader(xml)
loader.load()
self.registry = Registry(loader=loader)
class TestRegistry(unittest.TestCase):
def setUp(self):
xml = load.XML.FromFile(getTestFile())
loader = load.XMLLoader(xml)
loader.load()
self.registry = Registry(loader=loader)
def testGetItem(self):
value = self.registry['urn:ogc:def:crs:EPSG::27700']
self.assertIsInstance(value, schema.ProjectedCRS)
with self.assertRaises(TypeError):
self.registry[42]
with self.assertRaises(KeyError):
self.registry['bad key']
def testSetItem(self):
builder = SchemaBuilder()
key = 'urn:ogc:def:area:EPSG::0001'
value = builder.buildAreaOfUse()
value.identifier = key # replace the id with one not in the test database
self.registry[key] = value
self.assertEqual(value, self.registry[key])
def testDelItem(self):
del self.registry['urn:ogc:def:crs:EPSG::27700']
with self.assertRaises(KeyError):
self.registry['urn:ogc:def:crs:EPSG::27700']
def testLen(self):
self.assertEqual(45, len(self.registry))
def testUpdate(self):
registry2 = Registry(loader=False)
registry2.update(self.registry)
self.assertEqual(len(self.registry), len(registry2))
def testContains(self):
self.assertIn('urn:ogc:def:crs:EPSG::27700', self.registry)
self.assertNotIn('invalid key', self.registry)
def testIter(self):
count = 0
for key in self.registry:
self.assertIsInstance(key, (str, unicode))
count += 1
self.assertEqual(45, count)
def testItervalues(self):
count = 0
for value in self.registry.itervalues():
self.assertIsInstance(value, schema.Identifier)
count += 1
self.assertEqual(45, count)
def testIteritems(self):
count = 0
for item in self.registry.iteritems():
self.assertIsInstance(item, tuple)
self.assertEqual(2, len(item))
key, value = item
self.assertIsInstance(key, (str, unicode))
self.assertIsInstance(value, schema.Identifier)
count += 1
self.assertEqual(45, count)
