def layer_creation_shp(self, tmpdir):
self.dir = tmpdir.mkdir('layer_creation')
self.c = fiona.open(str(self.dir),
'w',
layer='write_test',
driver='ESRI Shapefile',
schema={
'geometry':
'Point',
'properties': [('title', 'str:80'),
('date', 'date')]
},
crs={
'init': "epsg:4326",
'no_defs': True
},
encoding='utf-8')
self.f = {
'type':
'Feature',
'geometry': {
'type': 'Point',
'coordinates': (0.0, 0.1)
},
'properties':
OrderedDict([('title', 'point one'), ('date', '2012-01-29')])
}
self.c.writerecords([self.f])
self.c.flush()
yield
self.c.close()
def multi_write_test_shp(self, tmpdir):
self.shapefile_path = str(tmpdir.join("multi_write_test.shp"))
self.c = fiona.open(self.shapefile_path,
"w",
driver="ESRI Shapefile",
schema={
'geometry':
'Point',
'properties': [('title', 'str:80'),
('date', 'date')]
},
crs={
'init': "epsg:4326",
'no_defs': True
},
encoding='utf-8')
self.f = {
'type':
'Feature',
'geometry': {
'type': 'Point',
'coordinates': (0.0, 0.1)
},
'properties':
OrderedDict([('title', 'point one'), ('date', '2012-01-29')])
}
self.c.writerecords([self.f])
self.c.flush()
yield
self.c.close()
def setUp(self):
self.tempdir = tempfile.mkdtemp()
self.c = fiona.open(os.path.join(self.tempdir, "multi_write_test.shp"),
"w",
driver="ESRI Shapefile",
schema={
'geometry':
'Point',
'properties': [('title', 'str:80'),
('date', 'date')]
},
crs={
'init': "epsg:4326",
'no_defs': True
},
encoding='utf-8')
self.f = {
'type':
'Feature',
'geometry': {
'type': 'Point',
'coordinates': (0.0, 0.1)
},
'properties':
OrderedDict([('title', 'point one'), ('date', '2012-01-29')])
}
self.c.writerecords([self.f])
self.c.flush()
def setUp(self):
self.tempdir = tempfile.mkdtemp()
self.dir = os.path.join(self.tempdir, 'layer_creation')
if os.path.exists(self.dir):
shutil.rmtree(self.dir)
os.mkdir(self.dir)
self.c = fiona.open(self.dir,
'w',
layer='write_test',
driver='ESRI Shapefile',
schema={
'geometry':
'Point',
'properties': [('title', 'str:80'),
('date', 'date')]
},
crs={
'init': "epsg:4326",
'no_defs': True
},
encoding='utf-8')
self.f = {
'type':
'Feature',
'geometry': {
'type': 'Point',
'coordinates': (0.0, 0.1)
},
'properties':
OrderedDict([('title', 'point one'), ('date', '2012-01-29')])
}
self.c.writerecords([self.f])
self.c.flush()
def open(fp,
mode='r',
driver=None,
schema=None,
crs=None,
encoding=None,
layer=None,
vfs=None,
enabled_drivers=None,
crs_wkt=None,
**kwargs):
"""Open a collection for read, append, or write
In write mode, a driver name such as "ESRI Shapefile" or "GPX" (see
OGR docs or ``ogr2ogr --help`` on the command line) and a schema
mapping such as:
{'geometry': 'Point',
'properties': [('class', 'int'), ('label', 'str'),
('value', 'float')]}
must be provided. If a particular ordering of properties ("fields"
in GIS parlance) in the written file is desired, a list of (key,
value) pairs as above or an ordered dict is required. If no ordering
is needed, a standard dict will suffice.
A coordinate reference system for collections in write mode can be
defined by the ``crs`` parameter. It takes Proj4 style mappings like
{'proj': 'longlat', 'ellps': 'WGS84', 'datum': 'WGS84',
'no_defs': True}
short hand strings like
EPSG:4326
or WKT representations of coordinate reference systems.
The drivers used by Fiona will try to detect the encoding of data
files. If they fail, you may provide the proper ``encoding``, such
as 'Windows-1252' for the Natural Earth datasets.
When the provided path is to a file containing multiple named layers
of data, a layer can be singled out by ``layer``.
The drivers enabled for opening datasets may be restricted to those
listed in the ``enabled_drivers`` parameter. This and the ``driver``
parameter afford much control over opening of files.
# Trying only the GeoJSON driver when opening to read, the
# following raises ``DataIOError``:
fiona.open('example.shp', driver='GeoJSON')
# Trying first the GeoJSON driver, then the Shapefile driver,
# the following succeeds:
fiona.open(
'example.shp', enabled_drivers=['GeoJSON', 'ESRI Shapefile'])
Parameters
----------
fp : URI (str or pathlib.Path), or file-like object
A dataset resource identifier or file object.
mode : str
One of 'r', to read (the default); 'a', to append; or 'w', to
write.
driver : str
In 'w' mode a format driver name is required. In 'r' or 'a'
mode this parameter has no effect.
schema : dict
Required in 'w' mode, has no effect in 'r' or 'a' mode.
crs : str or dict
Required in 'w' mode, has no effect in 'r' or 'a' mode.
encoding : str
Name of the encoding used to encode or decode the dataset.
layer : int or str
The integer index or name of a layer in a multi-layer dataset.
vfs : str
This is a deprecated parameter. A URI scheme such as "zip://"
should be used instead.
enabled_drivers : list
An optional list of driver names to used when opening a
collection.
crs_wkt : str
An optional WKT representation of a coordinate reference
system.
kwargs : mapping
Other driver-specific parameters that will be interpreted by
the OGR library as layer creation or opening options.
Returns
-------
Collection
"""
if mode == 'r' and hasattr(fp, 'read'):
@contextmanager
def fp_reader(fp):
memfile = MemoryFile(fp.read())
dataset = memfile.open()
try:
yield dataset
finally:
dataset.close()
memfile.close()
return fp_reader(fp)
elif mode == 'w' and hasattr(fp, 'write'):
if schema:
# Make an ordered dict of schema properties.
this_schema = schema.copy()
this_schema['properties'] = OrderedDict(schema['properties'])
else:
this_schema = None
@contextmanager
def fp_writer(fp):
memfile = MemoryFile()
dataset = memfile.open(driver=driver,
crs=crs,
schema=schema,
layer=layer,
encoding=encoding,
enabled_drivers=enabled_drivers,
**kwargs)
try:
yield dataset
finally:
dataset.close()
memfile.seek(0)
fp.write(memfile.read())
memfile.close()
return fp_writer(fp)
else:
# If a pathlib.Path instance is given, convert it to a string path.
if isinstance(fp, Path):
fp = str(fp)
if vfs:
# Parse the vfs into a vsi and an archive path.
path, scheme, archive = vfs_parse_paths(fp, vfs=vfs)
path = ParsedPath(path, archive, scheme)
else:
path = parse_path(fp)
if mode in ('a', 'r'):
c = Collection(path,
mode,
driver=driver,
encoding=encoding,
layer=layer,
enabled_drivers=enabled_drivers,
**kwargs)
elif mode == 'w':
if schema:
# Make an ordered dict of schema properties.
this_schema = schema.copy()
this_schema['properties'] = OrderedDict(schema['properties'])
else:
this_schema = None
c = Collection(path,
mode,
crs=crs,
driver=driver,
schema=this_schema,
encoding=encoding,
layer=layer,
enabled_drivers=enabled_drivers,
crs_wkt=crs_wkt,
**kwargs)
else:
raise ValueError(
"mode string must be one of 'r', 'w', or 'a', not %s" % mode)
return c
def open(path,
mode='r',
driver=None,
schema=None,
crs=None,
encoding=None,
layer=None,
vfs=None,
enabled_drivers=None,
crs_wkt=None):
"""Open file at ``path`` in ``mode`` "r" (read), "a" (append), or
"w" (write) and return a ``Collection`` object.
In write mode, a driver name such as "ESRI Shapefile" or "GPX" (see
OGR docs or ``ogr2ogr --help`` on the command line) and a schema
mapping such as:
{'geometry': 'Point',
'properties': [('class', 'int'), ('label', 'str'),
('value', 'float')]}
must be provided. If a particular ordering of properties ("fields"
in GIS parlance) in the written file is desired, a list of (key,
value) pairs as above or an ordered dict is required. If no ordering
is needed, a standard dict will suffice.
A coordinate reference system for collections in write mode can be
defined by the ``crs`` parameter. It takes Proj4 style mappings like
{'proj': 'longlat', 'ellps': 'WGS84', 'datum': 'WGS84',
'no_defs': True}
short hand strings like
EPSG:4326
or WKT representations of coordinate reference systems.
The drivers used by Fiona will try to detect the encoding of data
files. If they fail, you may provide the proper ``encoding``, such
as 'Windows-1252' for the Natural Earth datasets.
When the provided path is to a file containing multiple named layers
of data, a layer can be singled out by ``layer``.
A virtual filesystem can be specified. The ``vfs`` parameter may be
an Apache Commons VFS style string beginning with "zip://" or
"tar://"". In this case, the ``path`` must be an absolute path
within that container.
The drivers enabled for opening datasets may be restricted to those
listed in the ``enabled_drivers`` parameter. This and the ``driver``
parameter afford much control over opening of files.
# Trying only the GeoJSON driver when opening to read, the
# following raises ``DataIOError``:
fiona.open('example.shp', driver='GeoJSON')
# Trying first the GeoJSON driver, then the Shapefile driver,
# the following succeeds:
fiona.open(
'example.shp', enabled_drivers=['GeoJSON', 'ESRI Shapefile'])
"""
# Parse the vfs into a vsi and an archive path.
path, vsi, archive = parse_paths(path, vfs)
if mode in ('a', 'r'):
if archive:
if not os.path.exists(archive):
raise IOError("no such archive file: %r" % archive)
elif path != '-' and not os.path.exists(path):
raise IOError("no such file or directory: %r" % path)
c = Collection(path,
mode,
driver=driver,
encoding=encoding,
layer=layer,
vsi=vsi,
archive=archive,
enabled_drivers=enabled_drivers)
elif mode == 'w':
if schema:
# Make an ordered dict of schema properties.
this_schema = schema.copy()
this_schema['properties'] = OrderedDict(schema['properties'])
else:
this_schema = None
c = Collection(path,
mode,
crs=crs,
driver=driver,
schema=this_schema,
encoding=encoding,
layer=layer,
vsi=vsi,
archive=archive,
enabled_drivers=enabled_drivers,
crs_wkt=crs_wkt)
else:
raise ValueError(
"mode string must be one of 'r', 'w', or 'a', not %s" % mode)
return c
