예제 #1
0
    def testCreateBigIntSchema(self):
        name = os.path.join(self.tempdir, 'output1.shp')

        a_bigint = 10 ** 18 - 1
        fieldname = 'abigint'

        kwargs = {
            'driver': 'ESRI Shapefile',
            'crs': 'EPSG:4326',
            'schema': {
                'geometry': 'Point',
                'properties': [(fieldname, 'int:10')]}}
        if get_gdal_version_num() < calc_gdal_version_num(2, 0, 0):
            with self.assertRaises(OverflowError):
                with fiona.open(name, 'w', **kwargs) as dst:
                    rec = {}
                    rec['geometry'] = {'type': 'Point', 'coordinates': (0, 0)}
                    rec['properties'] = {fieldname: a_bigint}
                    dst.write(rec)
        else:

            with fiona.open(name, 'w', **kwargs) as dst:
                rec = {}
                rec['geometry'] = {'type': 'Point', 'coordinates': (0, 0)}
                rec['properties'] = {fieldname: a_bigint}
                dst.write(rec)

            with fiona.open(name) as src:
                if get_gdal_version_num() >= calc_gdal_version_num(2, 0, 0):
                    first = next(iter(src))
                    self.assertEqual(first['properties'][fieldname], a_bigint)
예제 #2
0
    def testCreateBigIntSchema(self):
        name = os.path.join(self.tempdir, 'output1.shp')

        a_bigint = 10**18 - 1
        fieldname = 'abigint'

        kwargs = {
            'driver': 'ESRI Shapefile',
            'crs': 'EPSG:4326',
            'schema': {
                'geometry': 'Point',
                'properties': [(fieldname, 'int:10')]
            }
        }
        if get_gdal_version_num() < calc_gdal_version_num(2, 0, 0):
            with self.assertRaises(OverflowError):
                with fiona.open(name, 'w', **kwargs) as dst:
                    rec = {}
                    rec['geometry'] = {'type': 'Point', 'coordinates': (0, 0)}
                    rec['properties'] = {fieldname: a_bigint}
                    dst.write(rec)
        else:

            with fiona.open(name, 'w', **kwargs) as dst:
                rec = {}
                rec['geometry'] = {'type': 'Point', 'coordinates': (0, 0)}
                rec['properties'] = {fieldname: a_bigint}
                dst.write(rec)

            with fiona.open(name) as src:
                if get_gdal_version_num() >= calc_gdal_version_num(2, 0, 0):
                    first = next(iter(src))
                    self.assertEqual(first['properties'][fieldname], a_bigint)
예제 #3
0
 def test_gpkg(self):
     if get_gdal_version_num() < calc_gdal_version_num(1, 11, 0):
         self.assertRaises(DriverError,
                           fiona.open,
                           'tests/data/coutwildrnp.gpkg',
                           'r',
                           driver="GPKG")
     else:
         with fiona.open('tests/data/coutwildrnp.gpkg', 'r',
                         driver="GPKG") as c:
             self.assertEquals(len(c), 48)
예제 #4
0
    def test_gpkg(self):
        schema = {'geometry': 'Point', 'properties': [('title', 'str')]}
        crs = {
            'a': 6370997,
            'lon_0': -100,
            'y_0': 0,
            'no_defs': True,
            'proj': 'laea',
            'x_0': 0,
            'units': 'm',
            'b': 6370997,
            'lat_0': 45
        }

        path = os.path.join(self.tempdir, 'foo.gpkg')

        if get_gdal_version_num() < calc_gdal_version_num(1, 11, 0):
            self.assertRaises(DriverError,
                              fiona.open,
                              path,
                              'w',
                              driver='GPKG',
                              schema=schema,
                              crs=crs)
        else:
            with fiona.open(path, 'w', driver='GPKG', schema=schema,
                            crs=crs) as c:
                c.writerecords([{
                    'geometry': {
                        'type': 'Point',
                        'coordinates': [0.0, 0.0]
                    },
                    'properties': {
                        'title': 'One'
                    }
                }])
                c.writerecords([{
                    'geometry': {
                        'type': 'Point',
                        'coordinates': [2.0, 3.0]
                    },
                    'properties': {
                        'title': 'Two'
                    }
                }])
            with fiona.open(path) as c:
                self.assertEquals(c.schema['geometry'], 'Point')
                self.assertEquals(len(c), 2)
예제 #5
0
    def _check_schema_driver_support(self):
        """Check support for the schema against the driver

        See GH#572 for discussion.
        """
        gdal_version_major = get_gdal_version_num() // 1000000
        for field in self._schema["properties"]:
            field_type = field.split(":")[0]
            if self._driver == "ESRI Shapefile":
                if field_type == "datetime":
                    raise DriverSupportError(
                        "ESRI Shapefile does not support datetime fields")
                elif field_type == "time":
                    raise DriverSupportError(
                        "ESRI Shapefile does not support time fields")
            elif self._driver == "GPKG":
                if field_type == "time":
                    raise DriverSupportError(
                        "GPKG does not support time fields")
                elif gdal_version_major == 1:
                    if field_type == "datetime":
                        raise DriverSupportError(
                            "GDAL 1.x GPKG driver does not support datetime fields"
                        )
            elif self._driver == "GeoJSON":
                if gdal_version_major == 1:
                    if field_type == "date":
                        warnings.warn(
                            "GeoJSON driver in GDAL 1.x silently converts date to string in non-standard format"
                        )
                    elif field_type == "datetime":
                        warnings.warn(
                            "GeoJSON driver in GDAL 1.x silently converts datetime to string in non-standard format"
                        )
                    elif field_type == "time":
                        warnings.warn(
                            "GeoJSON driver in GDAL 1.x silently converts time to string"
                        )
예제 #6
0
    def test_gpkg(self):
        schema = {'geometry': 'Point',
                  'properties': [('title', 'str')]}
        crs = {
            'a': 6370997,
            'lon_0': -100,
            'y_0': 0,
            'no_defs': True,
            'proj': 'laea',
            'x_0': 0,
            'units': 'm',
            'b': 6370997,
            'lat_0': 45}

        path = os.path.join(self.tempdir, 'foo.gpkg')
        
        if get_gdal_version_num() < calc_gdal_version_num(1, 11, 0):
            self.assertRaises(DriverError,
                        fiona.open,
                        path,
                        'w',
                        driver='GPKG',
                        schema=schema,
                        crs=crs)
        else:
            with fiona.open(path, 'w',
                            driver='GPKG',
                            schema=schema,
                            crs=crs) as c:
                c.writerecords([{
                    'geometry': {'type': 'Point', 'coordinates': [0.0, 0.0]},
                    'properties': {'title': 'One'}}])
                c.writerecords([{
                    'geometry': {'type': 'Point', 'coordinates': [2.0, 3.0]},
                    'properties': {'title': 'Two'}}])
            with fiona.open(path) as c:
                self.assertEquals(c.schema['geometry'], 'Point')
                self.assertEquals(len(c), 2)
    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,
                 **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):
            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 vsi not in ('zip', 'tar',
                                                                'gzip'):
                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_num() < calc_gdal_version_num(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.path = vsi_path(path, vsi, archive)

        if mode == 'w':
            if layer and not isinstance(layer, string_types):
                raise ValueError("in 'r' 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)[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

            if crs_wkt:
                self._crs_wkt = crs_wkt
            elif crs:
                if 'init' in crs or 'proj' in crs or 'epsg' in crs.lower():
                    self._crs = crs
                else:
                    raise CRSError("crs lacks init or proj parameter")

        if driver_count == 0:
            # create a local manager and enter
            self.env = GDALEnv()
        else:
            self.env = GDALEnv()
        self.env.__enter__()

        self._driver = driver
        self.encoding = encoding

        try:
            if self.mode == 'r':
                self.session = Session()
                self.session.start(self)
            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 not self.encoding:
                self.encoding = self.session.get_fileencoding().lower()
예제 #8
0
파일: collection.py 프로젝트: mwtoews/Fiona
    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):
            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_num() < calc_gdal_version_num(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)

        self.path = vfs.vsi_path(path, vsi, archive)

        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)[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

            if crs_wkt:
                self._crs_wkt = crs_wkt
            elif crs:
                if 'init' in crs or 'proj' in crs or 'epsg' in crs.lower():
                    self._crs = crs
                else:
                    raise CRSError("crs lacks init or proj parameter")

        if driver_count == 0:
            # create a local manager and enter
            self.env = AWSGDALEnv()
        else:
            self.env = AWSGDALEnv()
        self.env.__enter__()

        self._driver = driver
        kwargs.update(encoding=encoding or '')
        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 not self.encoding:
                self.encoding = self.session.get_fileencoding().lower()

        if self.mode in ("a", "w"):
            self._valid_geom_types = _get_valid_geom_types(self.schema, self.driver)
예제 #9
0
        'schema': {
            'geometry': 'BOGUS',
            'properties': {}}}

    try:
        fiona.open(tmpfile, 'w', **profile)
    except UnsupportedGeometryTypeError:
        assert True


@pytest.mark.parametrize('x', list(range(1, 10)))
def test_normalize_int32(x):
    assert normalize_field_type('int:{}'.format(x)) == 'int32'


@pytest.mark.skipif(get_gdal_version_num() < calc_gdal_version_num(2, 0, 0),
                    reason="64-bit integer fields require GDAL 2+")
@pytest.mark.parametrize('x', list(range(10, 20)))
def test_normalize_int64(x):
    assert normalize_field_type('int:{}'.format(x)) == 'int64'


@pytest.mark.parametrize('x', list(range(0, 20)))
def test_normalize_str(x):
    assert normalize_field_type('str:{}'.format(x)) == 'str'


def test_normalize_bool():
    assert normalize_field_type('bool') == 'bool'

예제 #10
0
 def test_gpkg(self):
     if get_gdal_version_num() < calc_gdal_version_num(1, 11, 0):
         self.assertRaises(DriverError, fiona.open, 'tests/data/coutwildrnp.gpkg', 'r', driver="GPKG")
     else:
         with fiona.open('tests/data/coutwildrnp.gpkg', 'r', driver="GPKG") as c:
             self.assertEquals(len(c), 48)
예제 #11
0
from fiona.ogrext import (
    calc_gdal_version_num, get_gdal_version_num, get_gdal_release_name)
import warnings

# These modules are imported by fiona.ogrext, but are also import here to
# help tools like cx_Freeze find them automatically
from fiona import _geometry, _err, rfc3339
import uuid


__all__ = ['bounds', 'listlayers', 'open', 'prop_type', 'prop_width']
__version__ = "1.6.4"
__gdal_version__ = get_gdal_release_name().decode('utf-8')

# Warn user that they use fiona 1.x with gdal 2.0
if get_gdal_version_num() >= calc_gdal_version_num(2, 0, 0):
    raise ImportError(
        "Fiona {0} is only compatible with GDAL 1.x (installed: {1})".format(
            __version__, __gdal_version__))

log = logging.getLogger('Fiona')
class NullHandler(logging.Handler):
    def emit(self, record):
        pass
log.addHandler(NullHandler())

def open(
        path,
        mode='r',
        driver=None,
        schema=None,