def test_towgs84_wkt(): """+towgs84 +wktext are preserved in WKT""" proj4 = ('+proj=lcc +lat_1=49 +lat_2=46 +lat_0=47.5 ' '+lon_0=13.33333333333333 +x_0=400000 +y_0=400000 +ellps=bessel ' '+towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232 ' '+units=m +wktext +no_defs') assert 'towgs84' in _crs.crs_to_wkt(proj4) assert 'wktext' in _crs.crs_to_wkt(proj4)
def test_custom_crs(): class CustomCRS(object): def to_wkt(self): return ( 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",' '6378137,298.257223563,AUTHORITY["EPSG","7030"]],' 'AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,' 'AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,' 'AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]') assert _crs.crs_to_wkt(CustomCRS()).startswith('GEOGCS["WGS 84"')
def test_write_memfile_crs_wkt(): example_schema = { "geometry": "Point", "properties": [("title", "str")], } example_features = [ { "geometry": { "type": "Point", "coordinates": [0.0, 0.0] }, "properties": { "title": "One" }, }, { "geometry": { "type": "Point", "coordinates": [1.0, 2.0] }, "properties": { "title": "Two" }, }, { "geometry": { "type": "Point", "coordinates": [3.0, 4.0] }, "properties": { "title": "Three" }, }, ] with io.BytesIO() as fd: with fiona.open( fd, "w", driver="GPKG", schema=example_schema, crs_wkt=crs_to_wkt("EPSG:32611"), ) as dst: dst.writerecords(example_features) fd.seek(0) with fiona.open(fd) as src: assert src.driver == "GPKG" assert src.crs == {"init": "epsg:32611"}
def __init__(self, path, mode='r', driver=None, schema=None, crs=None, encoding=None, layer=None, vsi=None, archive=None, enabled_drivers=None, crs_wkt=None, ignore_fields=None, ignore_geometry=False, **kwargs): """The required ``path`` is the absolute or relative path to a file, such as '/data/test_uk.shp'. In ``mode`` 'r', data can be read only. In ``mode`` 'a', data can be appended to a file. In ``mode`` 'w', data overwrites the existing contents of a file. In ``mode`` 'w', an OGR ``driver`` name and a ``schema`` are required. A Proj4 ``crs`` string is recommended. If both ``crs`` and ``crs_wkt`` keyword arguments are passed, the latter will trump the former. In 'w' mode, kwargs will be mapped to OGR layer creation options. """ if not isinstance(path, (string_types, Path)): raise TypeError("invalid path: %r" % path) if not isinstance(mode, string_types) or mode not in ('r', 'w', 'a'): raise TypeError("invalid mode: %r" % mode) if driver and not isinstance(driver, string_types): raise TypeError("invalid driver: %r" % driver) if schema and not hasattr(schema, 'get'): raise TypeError("invalid schema: %r" % schema) if crs and not isinstance(crs, compat.DICT_TYPES + string_types): raise TypeError("invalid crs: %r" % crs) if crs_wkt and not isinstance(crs_wkt, string_types): raise TypeError("invalid crs_wkt: %r" % crs_wkt) if encoding and not isinstance(encoding, string_types): raise TypeError("invalid encoding: %r" % encoding) if layer and not isinstance(layer, tuple(list(string_types) + [int])): raise TypeError("invalid name: %r" % layer) if vsi: if not isinstance(vsi, string_types) or not vfs.valid_vsi(vsi): raise TypeError("invalid vsi: %r" % vsi) if archive and not isinstance(archive, string_types): raise TypeError("invalid archive: %r" % archive) # Check GDAL version against drivers if (driver == "GPKG" and get_gdal_version_tuple() < (1, 11, 0)): raise DriverError( "GPKG driver requires GDAL 1.11.0, fiona was compiled " "against: {}".format(get_gdal_release_name())) self.session = None self.iterator = None self._len = 0 self._bounds = None self._driver = None self._schema = None self._crs = None self._crs_wkt = None self.env = None self.enabled_drivers = enabled_drivers self.ignore_fields = ignore_fields self.ignore_geometry = bool(ignore_geometry) if vsi: self.path = vfs.vsi_path(path, vsi, archive) path = parse_path(self.path) else: path = parse_path(path) self.path = vsi_path(path) if mode == 'w': if layer and not isinstance(layer, string_types): raise ValueError("in 'w' mode, layer names must be strings") if driver == 'GeoJSON': if layer is not None: raise ValueError("the GeoJSON format does not have layers") self.name = 'OgrGeoJSON' # TODO: raise ValueError as above for other single-layer formats. else: self.name = layer or os.path.basename( os.path.splitext(path.path)[0]) else: if layer in (0, None): self.name = 0 else: self.name = layer or os.path.basename( os.path.splitext(path)[0]) self.mode = mode if self.mode == 'w': if driver == 'Shapefile': driver = 'ESRI Shapefile' if not driver: raise DriverError("no driver") elif driver not in supported_drivers: raise DriverError("unsupported driver: %r" % driver) elif self.mode not in supported_drivers[driver]: raise DriverError("unsupported mode: %r" % self.mode) self._driver = driver if not schema: raise SchemaError("no schema") elif 'properties' not in schema: raise SchemaError("schema lacks: properties") elif 'geometry' not in schema: raise SchemaError("schema lacks: geometry") self._schema = schema self._check_schema_driver_support() if crs_wkt or crs: self._crs_wkt = crs_to_wkt(crs_wkt or crs) self._driver = driver kwargs.update(encoding=encoding) self.encoding = encoding try: if self.mode == 'r': self.session = Session() self.session.start(self, **kwargs) elif self.mode in ('a', 'w'): self.session = WritingSession() self.session.start(self, **kwargs) except IOError: self.session = None raise if self.session is not None: self.guard_driver_mode() if self.mode in ("a", "w"): self._valid_geom_types = _get_valid_geom_types( self.schema, self.driver) self.field_skip_log_filter = FieldSkipLogFilter()
def test_invalid_crs(invalid_input): with pytest.raises(CRSError): _crs.crs_to_wkt(invalid_input)