Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_unpack_srid_from_bin_forcing_srid(self):
e = WKBElement(self._bin, srid=9999, extended=True)
assert e.srid == 9999
assert wkb.loads(bytes_(e.data)).wkt == self._wkt
def test_desc(self):
e = WKBElement(b'\x01\x02')
assert e.desc == '0102'
def test_unpack_srid_from_hex(self):
e = WKBElement(self._hex, extended=True)
assert e.srid == self._srid
assert wkb.loads(e.data, hex=True).wkt == self._wkt
p = Point(1, 2)
e2 = from_shape(p, srid=2154)
assert isinstance(e2, WKBElement)
assert isinstance(e2.data, buffer)
assert e2 == expected2
s2 = shapely.wkb.loads(bytes(e2.data))
assert isinstance(s2, Point)
assert s2.equals(p)
# Extended case: SRID=2145;POINT(1 2)
expected3 = WKBElement(
str('01010000206a080000000000000000f03f0000000000000040'),
extended=True)
e3 = from_shape(p, srid=2154, extended=True)
assert isinstance(e3, WKBElement)
assert isinstance(e3.data, buffer)
assert e3 == expected3
s3 = shapely.wkb.loads(bytes(e3.data))
assert isinstance(s, Point)
assert s3.equals(p)
def test_from_shape():
# Standard case: POINT(1 2)
expected = WKBElement(str('0101000000000000000000f03f0000000000000040'))
p = Point(1, 2)
e = from_shape(p)
assert isinstance(e, WKBElement)
assert isinstance(e.data, buffer)
assert e == expected
s = shapely.wkb.loads(bytes(e.data))
assert isinstance(s, Point)
assert s.equals(p)
# Standard case with SRID: SRID=2145;POINT(1 2)
expected2 = WKBElement(str('0101000000000000000000f03f0000000000000040'), srid=2154)
p = Point(1, 2)
e2 = from_shape(p, srid=2154)
assert isinstance(e2, WKBElement)
assert isinstance(e2.data, buffer)
def test_eq(self):
a = WKBElement(self._ewkb, extended=True)
b = WKBElement(self._wkb, srid=self._srid)
c = WKTElement(self._wkt, srid=self._srid)
d = WKTElement(self._ewkt, extended=True)
e = WKBElement(self._hex, extended=True)
assert a == a
assert b == b
assert c == c
assert d == d
assert e == e
assert a == e and e == a
def test_neq_other_types(self):
a = WKBElement(self._ewkb, extended=True)
b = WKBElement(self._wkb, srid=self._srid)
c = WKTElement(self._wkt, srid=self._srid)
d = WKTElement(self._ewkt, extended=True)
e = WKBElement(self._hex, extended=True)
all_elements = [a, b, c, d, None, 1, "test"]
for i, j in permutations(all_elements, 2):
assert i != j
for i in all_elements[1:]:
assert i != e and e != i
def to_shape(element):
"""
Function to convert a :class:`geoalchemy2.types.SpatialElement`
to a Shapely geometry.
Example::
lake = Session.query(Lake).get(1)
polygon = to_shape(lake.geom)
"""
assert isinstance(element, (WKBElement, WKTElement))
if isinstance(element, WKBElement):
data, hex = (element.data, True) if isinstance(element.data, str) else \
(bytes(element.data), False)
return shapely.wkb.loads(data, hex=hex)
elif isinstance(element, WKTElement):
if element.extended:
return shapely.wkt.loads(element.data.split(';', 1)[1])
else:
return shapely.wkt.loads(element.data)
def order_by_distance(cls, geometry, geometryType, imageDisplay, mapExtent, tolerance, limit, srid):
tolerance_meters = get_tolerance_meters(imageDisplay, mapExtent, tolerance)
# If limit is equal to 1 we have to be accurate
if tolerance_meters <= 250.0 or limit == 1:
wkb_geometry = WKBElement(buffer(geometry.wkb), srid)
geom_column = cls.geometry_column()
return func.ST_DISTANCE(geom_column, transform_geometry(geom_column, wkb_geometry, srid))
return None
def process(bindvalue):
if isinstance(bindvalue, WKTElement):
if bindvalue.extended:
return '%s' % (bindvalue.data)
else:
return 'SRID=%d;%s' % (bindvalue.srid, bindvalue.data)
elif isinstance(bindvalue, WKBElement):
if dialect.name == 'sqlite' or not bindvalue.extended:
# With SpatiaLite or when the WKBElement includes a WKB value rather
# than a EWKB value we use Shapely to convert the WKBElement to an
# EWKT string
if not SHAPELY:
raise ArgumentError('Shapely is required for handling WKBElement bind '
'values when using SpatiaLite or when the bind value '
'is a WKB rather than an EWKB')
shape = to_shape(bindvalue)
return 'SRID=%d;%s' % (bindvalue.srid, shape.wkt)
else:
# PostGIS ST_GeomFromEWKT works with EWKT strings as well
# as EWKB hex strings
return bindvalue.desc
elif isinstance(bindvalue, RasterElement):
return '%s' % (bindvalue.data)