pyogrio 0.9.0__cp310-cp310-macosx_12_0_arm64.whl

pyogrio/__init__.py

@@ -0,0 +1,48 @@
+try:
+    # we try importing shapely, to ensure it is imported (and it can load its
+    # own GEOS copy) before we load GDAL and its linked GEOS
+    import shapely  # noqa
+    import shapely.geos  # noqa
+except Exception:
+    pass
+
+from pyogrio.core import (
+    list_drivers,
+    detect_write_driver,
+    list_layers,
+    read_bounds,
+    read_info,
+    set_gdal_config_options,
+    get_gdal_config_option,
+    get_gdal_data_path,
+    __gdal_version__,
+    __gdal_version_string__,
+    __gdal_geos_version__,
+)
+from pyogrio.raw import read_arrow, open_arrow, write_arrow
+from pyogrio.geopandas import read_dataframe, write_dataframe
+from pyogrio._version import get_versions
+
+
+__version__ = get_versions()["version"]
+del get_versions
+
+__all__ = [
+    "list_drivers",
+    "detect_write_driver",
+    "list_layers",
+    "read_bounds",
+    "read_info",
+    "set_gdal_config_options",
+    "get_gdal_config_option",
+    "get_gdal_data_path",
+    "read_arrow",
+    "open_arrow",
+    "write_arrow",
+    "read_dataframe",
+    "write_dataframe",
+    "__gdal_version__",
+    "__gdal_version_string__",
+    "__gdal_geos_version__",
+    "__version__",
+]

pyogrio/_compat.py

@@ -0,0 +1,41 @@
+from packaging.version import Version
+
+from pyogrio.core import __gdal_version__, __gdal_geos_version__
+
+# detect optional dependencies
+try:
+    import pyarrow
+except ImportError:
+    pyarrow = None
+
+try:
+    import shapely
+except ImportError:
+    shapely = None
+
+try:
+    import geopandas
+except ImportError:
+    geopandas = None
+
+try:
+    import pandas
+except ImportError:
+    pandas = None
+
+
+HAS_ARROW_API = __gdal_version__ >= (3, 6, 0)
+HAS_ARROW_WRITE_API = __gdal_version__ >= (3, 8, 0)
+HAS_PYARROW = pyarrow is not None
+
+HAS_GEOPANDAS = geopandas is not None
+
+PANDAS_GE_15 = pandas is not None and Version(pandas.__version__) >= Version("1.5.0")
+PANDAS_GE_20 = pandas is not None and Version(pandas.__version__) >= Version("2.0.0")
+PANDAS_GE_22 = pandas is not None and Version(pandas.__version__) >= Version("2.2.0")
+
+GDAL_GE_38 = __gdal_version__ >= (3, 8, 0)
+
+HAS_GDAL_GEOS = __gdal_geos_version__ is not None
+
+HAS_SHAPELY = shapely is not None and Version(shapely.__version__) >= Version("2.0.0")

pyogrio/_env.py

@@ -0,0 +1,61 @@
+# With Python >= 3.8 on Windows directories in PATH are not automatically
+# searched for DLL dependencies and must be added manually with
+# os.add_dll_directory.
+# adapted from Fiona: https://github.com/Toblerity/Fiona/pull/875
+
+
+from contextlib import contextmanager
+import logging
+import os
+from pathlib import Path
+import platform
+import sys
+
+
+log = logging.getLogger(__name__)
+log.addHandler(logging.NullHandler())
+
+
+try:
+    # set GDAL_CURL_CA_BUNDLE / PROJ_CURL_CA_BUNDLE for GDAL >= 3.2
+    import certifi
+
+    ca_bundle = certifi.where()
+    os.environ.setdefault("GDAL_CURL_CA_BUNDLE", ca_bundle)
+    os.environ.setdefault("PROJ_CURL_CA_BUNDLE", ca_bundle)
+except ImportError:
+    pass
+
+
+gdal_dll_dir = None
+
+if platform.system() == "Windows" and sys.version_info >= (3, 8):
+    # if loading of extension modules fails, search for gdal dll directory
+    try:
+        import pyogrio._io  # NOQA
+
+    except ImportError:
+        for path in os.getenv("PATH", "").split(os.pathsep):
+            if list(Path(path).glob("gdal*.dll")):
+                log.info(f"Found GDAL at {path}")
+                gdal_dll_dir = path
+                break
+
+        if not gdal_dll_dir:
+            raise ImportError(
+                "GDAL DLL could not be found.  It must be on the system PATH."
+            )
+
+
+@contextmanager
+def GDALEnv():
+    dll_dir = None
+
+    if gdal_dll_dir:
+        dll_dir = os.add_dll_directory(gdal_dll_dir)
+
+    try:
+        yield None
+    finally:
+        if dll_dir is not None:
+            dll_dir.close()

pyogrio/_err.pxd

@@ -0,0 +1,4 @@
+cdef object exc_check()
+cdef int exc_wrap_int(int retval) except -1
+cdef int exc_wrap_ogrerr(int retval) except -1
+cdef void *exc_wrap_pointer(void *ptr) except NULL

pyogrio/_err.pyx

@@ -0,0 +1,250 @@
+# ported from fiona::_err.pyx
+from enum import IntEnum
+import warnings
+
+from pyogrio._ogr cimport (
+    CE_None, CE_Debug, CE_Warning, CE_Failure, CE_Fatal, CPLErrorReset,
+    CPLGetLastErrorType, CPLGetLastErrorNo, CPLGetLastErrorMsg, OGRErr,
+    CPLErr, CPLErrorHandler, CPLDefaultErrorHandler, CPLPushErrorHandler)
+
+
+# CPL Error types as an enum.
+class GDALError(IntEnum):
+    none = CE_None
+    debug = CE_Debug
+    warning = CE_Warning
+    failure = CE_Failure
+    fatal = CE_Fatal
+
+
+
+class CPLE_BaseError(Exception):
+    """Base CPL error class.
+    For internal use within Cython only.
+    """
+
+    def __init__(self, error, errno, errmsg):
+        self.error = error
+        self.errno = errno
+        self.errmsg = errmsg
+
+    def __str__(self):
+        return self.__unicode__()
+
+    def __unicode__(self):
+        return u"{}".format(self.errmsg)
+
+    @property
+    def args(self):
+        return self.error, self.errno, self.errmsg
+
+
+class CPLE_AppDefinedError(CPLE_BaseError):
+    pass
+
+
+class CPLE_OutOfMemoryError(CPLE_BaseError):
+    pass
+
+
+class CPLE_FileIOError(CPLE_BaseError):
+    pass
+
+
+class CPLE_OpenFailedError(CPLE_BaseError):
+    pass
+
+
+class CPLE_IllegalArgError(CPLE_BaseError):
+    pass
+
+
+class CPLE_NotSupportedError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AssertionFailedError(CPLE_BaseError):
+    pass
+
+
+class CPLE_NoWriteAccessError(CPLE_BaseError):
+    pass
+
+
+class CPLE_UserInterruptError(CPLE_BaseError):
+    pass
+
+
+class ObjectNullError(CPLE_BaseError):
+    pass
+
+
+class CPLE_HttpResponseError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AWSBucketNotFoundError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AWSObjectNotFoundError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AWSAccessDeniedError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AWSInvalidCredentialsError(CPLE_BaseError):
+    pass
+
+
+class CPLE_AWSSignatureDoesNotMatchError(CPLE_BaseError):
+    pass
+
+
+class NullPointerError(CPLE_BaseError):
+    """
+    Returned from exc_wrap_pointer when a NULL pointer is passed, but no GDAL
+    error was raised.
+    """
+    pass
+
+
+
+# Map of GDAL error numbers to the Python exceptions.
+exception_map = {
+    1: CPLE_AppDefinedError,
+    2: CPLE_OutOfMemoryError,
+    3: CPLE_FileIOError,
+    4: CPLE_OpenFailedError,
+    5: CPLE_IllegalArgError,
+    6: CPLE_NotSupportedError,
+    7: CPLE_AssertionFailedError,
+    8: CPLE_NoWriteAccessError,
+    9: CPLE_UserInterruptError,
+    10: ObjectNullError,
+
+    # error numbers 11-16 are introduced in GDAL 2.1. See
+    # https://github.com/OSGeo/gdal/pull/98.
+    11: CPLE_HttpResponseError,
+    12: CPLE_AWSBucketNotFoundError,
+    13: CPLE_AWSObjectNotFoundError,
+    14: CPLE_AWSAccessDeniedError,
+    15: CPLE_AWSInvalidCredentialsError,
+    16: CPLE_AWSSignatureDoesNotMatchError
+}
+
+
+cdef inline object exc_check():
+    """Checks GDAL error stack for fatal or non-fatal errors
+    Returns
+    -------
+    An Exception, SystemExit, or None
+    """
+    cdef const char *msg_c = NULL
+
+    err_type = CPLGetLastErrorType()
+    err_no = CPLGetLastErrorNo()
+    err_msg = CPLGetLastErrorMsg()
+
+    if err_msg == NULL:
+        msg = "No error message."
+    else:
+        # Reformat messages.
+        msg_b = err_msg
+
+        try:
+            msg = msg_b.decode('utf-8')
+            msg = msg.replace("`", "'")
+            msg = msg.replace("\n", " ")
+        except UnicodeDecodeError as exc:
+            msg = f"Could not decode error message to UTF-8.  Raw error: {msg_b}"
+
+    if err_type == 3:
+        CPLErrorReset()
+        return exception_map.get(
+            err_no, CPLE_BaseError)(err_type, err_no, msg)
+
+    if err_type == 4:
+        return SystemExit("Fatal error: {0}".format((err_type, err_no, msg)))
+
+    else:
+        return
+
+
+cdef void *exc_wrap_pointer(void *ptr) except NULL:
+    """Wrap a GDAL/OGR function that returns GDALDatasetH etc (void *)
+    Raises an exception if a non-fatal error has be set or if pointer is NULL.
+    """
+    if ptr == NULL:
+        exc = exc_check()
+        if exc:
+            raise exc
+        else:
+            # null pointer was passed, but no error message from GDAL
+            raise NullPointerError(-1, -1, "NULL pointer error")
+    return ptr
+
+
+cdef int exc_wrap_int(int err) except -1:
+    """Wrap a GDAL/OGR function that returns CPLErr or OGRErr (int)
+    Raises an exception if a non-fatal error has be set.
+
+    Copied from Fiona (_err.pyx).
+    """
+    if err:
+        exc = exc_check()
+        if exc:
+            raise exc
+        else:
+            # no error message from GDAL
+            raise CPLE_BaseError(-1, -1, "Unspecified OGR / GDAL error")
+    return err
+
+
+cdef int exc_wrap_ogrerr(int err) except -1:
+    """Wrap a function that returns OGRErr (int) but does not use the
+    CPL error stack.
+
+    Adapted from Fiona (_err.pyx).
+    """
+    if err != 0:
+        raise CPLE_BaseError(3, err, f"OGR Error code {err}")
+
+    return err
+
+
+cdef void error_handler(CPLErr err_class, int err_no, const char* err_msg) nogil:
+    """Custom CPL error handler to match the Python behaviour.
+
+    Generally we want to suppress error printing to stderr (behaviour of the
+    default GDAL error handler) because we already raise a Python exception
+    that includes the error message.
+    """
+    if err_class == CE_Fatal:
+        # If the error class is CE_Fatal, we want to have a message issued
+        # because the CPL support code does an abort() before any exception
+        # can be generated
+        CPLDefaultErrorHandler(err_class, err_no, err_msg)
+        return
+
+    elif err_class == CE_Failure:
+        # For Failures, do nothing as those are explicitly caught
+        # with error return codes and translated into Python exceptions
+        return
+
+    elif err_class == CE_Warning:
+        with gil:
+            msg_b = err_msg
+            msg = msg_b.decode('utf-8')
+            warnings.warn(msg, RuntimeWarning)
+        return
+
+    # Fall back to the default handler for non-failure messages since
+    # they won't be translated into exceptions.
+    CPLDefaultErrorHandler(err_class, err_no, err_msg)
+
+
+def _register_error_handler():
+    CPLPushErrorHandler(<CPLErrorHandler>error_handler)

pyogrio/_geometry.pxd

@@ -0,0 +1,4 @@
+from pyogrio._ogr cimport *
+
+cdef str get_geometry_type(void *ogr_layer)
+cdef OGRwkbGeometryType get_geometry_type_code(str geometry_type) except *

pyogrio/_geometry.pyx

@@ -0,0 +1,129 @@
+import warnings
+from pyogrio._ogr cimport *
+from pyogrio._err cimport *
+from pyogrio._err import CPLE_BaseError, NullPointerError
+from pyogrio.errors import DataLayerError, GeometryError
+
+
+# Mapping of OGR integer geometry types to GeoJSON type names.
+
+GEOMETRY_TYPES = {
+    wkbUnknown: 'Unknown',
+    wkbPoint: 'Point',
+    wkbLineString: 'LineString',
+    wkbPolygon: 'Polygon',
+    wkbMultiPoint: 'MultiPoint',
+    wkbMultiLineString: 'MultiLineString',
+    wkbMultiPolygon: 'MultiPolygon',
+    wkbGeometryCollection: 'GeometryCollection',
+    wkbNone: None,
+    wkbLinearRing: 'LinearRing',
+    # WARNING: Measured types are not supported in GEOS and downstream uses
+    # these are stripped automatically to their corresponding 2D / 3D types
+    wkbPointM: 'PointM',
+    wkbLineStringM: 'Measured LineString',
+    wkbPolygonM: 'Measured Polygon',
+    wkbMultiPointM: 'Measured MultiPoint',
+    wkbMultiLineStringM: 'Measured MultiLineString',
+    wkbMultiPolygonM: 'Measured MultiPolygon',
+    wkbGeometryCollectionM: 'Measured GeometryCollection',
+    wkbPointZM: 'Measured 3D Point',
+    wkbLineStringZM: 'Measured 3D LineString',
+    wkbPolygonZM: 'Measured 3D Polygon',
+    wkbMultiPointZM: 'Measured 3D MultiPoint',
+    wkbMultiLineStringZM: 'Measured 3D MultiLineString',
+    wkbMultiPolygonZM: 'Measured 3D MultiPolygon',
+    wkbGeometryCollectionZM: 'Measured 3D GeometryCollection',
+    wkbPoint25D: 'Point Z',
+    wkbLineString25D: 'LineString Z',
+    wkbPolygon25D: 'Polygon Z',
+    wkbMultiPoint25D: 'MultiPoint Z',
+    wkbMultiLineString25D: 'MultiLineString Z',
+    wkbMultiPolygon25D: 'MultiPolygon Z',
+    wkbGeometryCollection25D: 'GeometryCollection Z',
+}
+
+GEOMETRY_TYPE_CODES = {v:k for k, v in GEOMETRY_TYPES.items()}
+
+# add additional aliases from 2.5D format
+GEOMETRY_TYPE_CODES.update({
+    '2.5D Point': wkbPoint25D,
+    '2.5D LineString': wkbLineString25D,
+    '2.5D Polygon': wkbPolygon25D,
+    '2.5D MultiPoint': wkbMultiPoint25D,
+    '2.5D MultiLineString': wkbMultiLineString25D,
+    '2.5D MultiPolygon': wkbMultiPolygon25D,
+    '2.5D GeometryCollection': wkbGeometryCollection25D
+})
+
+# 2.5D also represented using negative numbers not enumerated above
+GEOMETRY_TYPES.update({
+    -2147483647: 'Point Z',
+    -2147483646: 'LineString Z',
+    -2147483645: 'Polygon Z',
+    -2147483644: 'MultiPoint Z',
+    -2147483643: 'MultiLineString Z',
+    -2147483642: 'MultiPolygon Z',
+    -2147483641: 'GeometryCollection Z',
+})
+
+
+cdef str get_geometry_type(void *ogr_layer):
+    """Get geometry type for layer.
+
+    Parameters
+    ----------
+    ogr_layer : pointer to open OGR layer
+
+    Returns
+    -------
+    str
+        geometry type
+    """
+    cdef void *cogr_featuredef = NULL
+    cdef OGRwkbGeometryType ogr_type
+
+    try:
+        ogr_featuredef = exc_wrap_pointer(OGR_L_GetLayerDefn(ogr_layer))
+    except NullPointerError:
+        raise DataLayerError("Could not get layer definition")
+
+    except CPLE_BaseError as exc:
+        raise DataLayerError(str(exc))
+
+    ogr_type = OGR_FD_GetGeomType(ogr_featuredef)
+
+    if ogr_type not in GEOMETRY_TYPES:
+        raise GeometryError(f"Geometry type is not supported: {ogr_type}")
+
+    if OGR_GT_HasM(ogr_type):
+        original_type = GEOMETRY_TYPES[ogr_type]
+
+        # Downgrade the type to 2D / 3D
+        ogr_type = OGR_GT_SetModifier(ogr_type, OGR_GT_HasZ(ogr_type), 0)
+
+        # TODO: review; this might be annoying...
+        warnings.warn(
+            "Measured (M) geometry types are not supported. "
+            f"Original type '{original_type}' "
+            f"is converted to '{GEOMETRY_TYPES[ogr_type]}'")
+
+    return GEOMETRY_TYPES[ogr_type]
+
+
+cdef OGRwkbGeometryType get_geometry_type_code(str geometry_type) except *:
+    """Get geometry type code for string geometry type.
+
+    Parameters
+    ----------
+    geometry_type : str
+
+    Returns
+    -------
+    int
+        geometry type code
+    """
+    if geometry_type not in GEOMETRY_TYPE_CODES:
+        raise GeometryError(f"Geometry type is not supported: {geometry_type}")
+
+    return GEOMETRY_TYPE_CODES[geometry_type]