pyogrio 0.10.0__cp313-cp313-win_amd64.whl

pyogrio/core.py

@@ -0,0 +1,386 @@
+"""Core functions to interact with OGR data sources."""
+
+from pathlib import Path
+from typing import Optional, Union
+
+from pyogrio._env import GDALEnv
+from pyogrio.util import (
+    _mask_to_wkb,
+    _preprocess_options_key_value,
+    get_vsi_path_or_buffer,
+)
+
+with GDALEnv():
+    from pyogrio._err import _register_error_handler
+    from pyogrio._io import ogr_list_layers, ogr_read_bounds, ogr_read_info
+    from pyogrio._ogr import (
+        _get_drivers_for_path,
+        _register_drivers,
+        get_gdal_config_option as _get_gdal_config_option,
+        get_gdal_data_path as _get_gdal_data_path,
+        get_gdal_geos_version,
+        get_gdal_version,
+        get_gdal_version_string,
+        init_gdal_data as _init_gdal_data,
+        init_proj_data as _init_proj_data,
+        ogr_list_drivers,
+        set_gdal_config_options as _set_gdal_config_options,
+    )
+    from pyogrio._vsi import (
+        ogr_vsi_listtree,
+        ogr_vsi_rmtree,
+        ogr_vsi_unlink,
+    )
+
+    _init_gdal_data()
+    _init_proj_data()
+    _register_drivers()
+    _register_error_handler()
+
+    __gdal_version__ = get_gdal_version()
+    __gdal_version_string__ = get_gdal_version_string()
+    __gdal_geos_version__ = get_gdal_geos_version()
+
+
+def list_drivers(read=False, write=False):
+    """List drivers available in GDAL.
+
+    Parameters
+    ----------
+    read: bool, optional (default: False)
+        If True, will only return drivers that are known to support read capabilities.
+    write: bool, optional (default: False)
+        If True, will only return drivers that are known to support write capabilities.
+
+    Returns
+    -------
+    dict
+        Mapping of driver name to file mode capabilities: ``"r"``: read, ``"w"``: write.
+        Drivers that are available but with unknown support are marked with ``"?"``
+
+    """
+    drivers = ogr_list_drivers()
+
+    if read:
+        drivers = {k: v for k, v in drivers.items() if v.startswith("r")}
+
+    if write:
+        drivers = {k: v for k, v in drivers.items() if v.endswith("w")}
+
+    return drivers
+
+
+def detect_write_driver(path):
+    """Attempt to infer the driver for a path by extension or prefix.
+
+    Only drivers that support write capabilities will be detected.
+
+    If the path cannot be resolved to a single driver, a ValueError will be
+    raised.
+
+    Parameters
+    ----------
+    path : str
+        data source path
+
+    Returns
+    -------
+    str
+        name of the driver, if detected
+
+    """
+    # try to infer driver from path
+    drivers = _get_drivers_for_path(path)
+
+    if len(drivers) == 0:
+        raise ValueError(
+            f"Could not infer driver from path: {path}; please specify driver "
+            "explicitly"
+        )
+
+    # if there are multiple drivers detected, user needs to specify the correct
+    # one manually
+    elif len(drivers) > 1:
+        raise ValueError(
+            f"Could not infer driver from path: {path}; multiple drivers are "
+            f"available for that extension: {', '.join(drivers)}.  Please "
+            "specify driver explicitly."
+        )
+
+    return drivers[0]
+
+
+def list_layers(path_or_buffer, /):
+    """List layers available in an OGR data source.
+
+    NOTE: includes both spatial and nonspatial layers.
+
+    Parameters
+    ----------
+    path_or_buffer : str, pathlib.Path, bytes, or file-like
+        A dataset path or URI, raw buffer, or file-like object with a read method.
+
+    Returns
+    -------
+    ndarray shape (2, n)
+        array of pairs of [<layer name>, <layer geometry type>]
+        Note: geometry is `None` for nonspatial layers.
+
+    """
+    return ogr_list_layers(get_vsi_path_or_buffer(path_or_buffer))
+
+
+def read_bounds(
+    path_or_buffer,
+    /,
+    layer=None,
+    skip_features=0,
+    max_features=None,
+    where=None,
+    bbox=None,
+    mask=None,
+):
+    """Read bounds of each feature.
+
+    This can be used to assist with spatial indexing and partitioning, in
+    order to avoid reading all features into memory.  It is roughly 2-3x faster
+    than reading the full geometry and attributes of a dataset.
+
+    Parameters
+    ----------
+    path_or_buffer : str, pathlib.Path, bytes, or file-like
+        A dataset path or URI, raw buffer, or file-like object with a read method.
+    layer : int or str, optional (default: first layer)
+        If an integer is provided, it corresponds to the index of the layer
+        with the data source.  If a string is provided, it must match the name
+        of the layer in the data source.  Defaults to first layer in data source.
+    skip_features : int, optional (default: 0)
+        Number of features to skip from the beginning of the file before returning
+        features.  Must be less than the total number of features in the file.
+    max_features : int, optional (default: None)
+        Number of features to read from the file.  Must be less than the total
+        number of features in the file minus ``skip_features`` (if used).
+    where : str, optional (default: None)
+        Where clause to filter features in layer by attribute values.  Uses a
+        restricted form of SQL WHERE clause, defined here:
+        http://ogdi.sourceforge.net/prop/6.2.CapabilitiesMetadata.html
+        Examples: ``"ISO_A3 = 'CAN'"``, ``"POP_EST > 10000000 AND POP_EST < 100000000"``
+    bbox : tuple of (xmin, ymin, xmax, ymax), optional (default: None)
+        If present, will be used to filter records whose geometry intersects this
+        box.  This must be in the same CRS as the dataset.  If GEOS is present
+        and used by GDAL, only geometries that intersect this bbox will be
+        returned; if GEOS is not available or not used by GDAL, all geometries
+        with bounding boxes that intersect this bbox will be returned.
+    mask : Shapely geometry, optional (default: None)
+        If present, will be used to filter records whose geometry intersects
+        this geometry.  This must be in the same CRS as the dataset.  If GEOS is
+        present and used by GDAL, only geometries that intersect this geometry
+        will be returned; if GEOS is not available or not used by GDAL, all
+        geometries with bounding boxes that intersect the bounding box of this
+        geometry will be returned.  Requires Shapely >= 2.0.
+        Cannot be combined with ``bbox`` keyword.
+
+    Returns
+    -------
+    tuple of (fids, bounds)
+        fids are global IDs read from the FID field of the dataset
+        bounds are ndarray of shape(4, n) containing ``xmin``, ``ymin``, ``xmax``,
+        ``ymax``
+
+    """
+    return ogr_read_bounds(
+        get_vsi_path_or_buffer(path_or_buffer),
+        layer=layer,
+        skip_features=skip_features,
+        max_features=max_features or 0,
+        where=where,
+        bbox=bbox,
+        mask=_mask_to_wkb(mask),
+    )
+
+
+def read_info(
+    path_or_buffer,
+    /,
+    layer=None,
+    encoding=None,
+    force_feature_count=False,
+    force_total_bounds=False,
+    **kwargs,
+):
+    """Read information about an OGR data source.
+
+    ``crs``, ``geometry`` and ``total_bounds`` will be ``None`` and ``features`` will be
+    0 for a nonspatial layer.
+
+    ``features`` will be -1 if this is an expensive operation for this driver. You can
+    force it to be calculated using the ``force_feature_count`` parameter.
+
+    ``total_bounds`` is the 2-dimensional extent of all features within the dataset:
+    (xmin, ymin, xmax, ymax). It will be None if this is an expensive operation for this
+    driver or if the data source is nonspatial. You can force it to be calculated using
+    the ``force_total_bounds`` parameter.
+
+    ``fid_column`` is the name of the FID field in the data source, if the FID is
+    physically stored (e.g. in GPKG). If the FID is just a sequence, ``fid_column``
+    will be "" (e.g. ESRI Shapefile).
+
+    ``geometry_name`` is the name of the field where the main geometry is stored in the
+    data data source, if the field name can by customized (e.g. in GPKG). If no custom
+    name is supported, ``geometry_name`` will be "" (e.g. ESRI Shapefile).
+
+    ``encoding`` will be ``UTF-8`` if either the native encoding is likely to be
+    ``UTF-8`` or GDAL can automatically convert from the detected native encoding
+    to ``UTF-8``.
+
+    Parameters
+    ----------
+    path_or_buffer : str, pathlib.Path, bytes, or file-like
+        A dataset path or URI, raw buffer, or file-like object with a read method.
+    layer : [type], optional
+        Name or index of layer in data source.  Reads the first layer by default.
+    encoding : [type], optional (default: None)
+        If present, will be used as the encoding for reading string values from
+        the data source, unless encoding can be inferred directly from the data
+        source.
+    force_feature_count : bool, optional (default: False)
+        True if the feature count should be computed even if it is expensive.
+    force_total_bounds : bool, optional (default: False)
+        True if the total bounds should be computed even if it is expensive.
+    **kwargs
+        Additional driver-specific dataset open options passed to OGR.  Invalid
+        options will trigger a warning.
+
+    Returns
+    -------
+    dict
+        A dictionary with the following keys::
+
+            {
+                "layer_name": "<layer name>",
+                "crs": "<crs>",
+                "fields": <ndarray of field names>,
+                "dtypes": <ndarray of field dtypes>,
+                "encoding": "<encoding>",
+                "fid_column": "<fid column name or "">",
+                "geometry_name": "<geometry column name or "">",
+                "geometry_type": "<geometry type>",
+                "features": <feature count or -1>,
+                "total_bounds": <tuple with total bounds or None>,
+                "driver": "<driver>",
+                "capabilities": "<dict of driver capabilities>"
+                "dataset_metadata": "<dict of dataset metadata or None>"
+                "layer_metadata": "<dict of layer metadata or None>"
+            }
+
+    """
+    dataset_kwargs = _preprocess_options_key_value(kwargs) if kwargs else {}
+
+    return ogr_read_info(
+        get_vsi_path_or_buffer(path_or_buffer),
+        layer=layer,
+        encoding=encoding,
+        force_feature_count=force_feature_count,
+        force_total_bounds=force_total_bounds,
+        dataset_kwargs=dataset_kwargs,
+    )
+
+
+def set_gdal_config_options(options):
+    """Set GDAL configuration options.
+
+    Options are listed here: https://trac.osgeo.org/gdal/wiki/ConfigOptions
+
+    No error is raised if invalid option names are provided.
+
+    These options are applied for an entire session rather than for individual
+    functions.
+
+    Parameters
+    ----------
+    options : dict
+        If present, provides a mapping of option name / value pairs for GDAL
+        configuration options.  ``True`` / ``False`` are normalized to ``'ON'``
+        / ``'OFF'``. A value of ``None`` for a config option can be used to clear out a
+        previously set value.
+
+    """
+    _set_gdal_config_options(options)
+
+
+def get_gdal_config_option(name):
+    """Get the value for a GDAL configuration option.
+
+    Parameters
+    ----------
+    name : str
+        name of the option to retrive
+
+    Returns
+    -------
+    value of the option or None if not set
+        ``'ON'`` / ``'OFF'`` are normalized to ``True`` / ``False``.
+
+    """
+    return _get_gdal_config_option(name)
+
+
+def get_gdal_data_path():
+    """Get the path to the directory GDAL uses to read data files.
+
+    Returns
+    -------
+    str, or None if data directory was not found
+
+    """
+    return _get_gdal_data_path()
+
+
+def vsi_listtree(path: Union[str, Path], pattern: Optional[str] = None):
+    """Recursively list the contents of a VSI directory.
+
+    An fnmatch pattern can be specified to filter the directories/files
+    returned.
+
+    Parameters
+    ----------
+    path : str or pathlib.Path
+        Path to the VSI directory to be listed.
+    pattern : str, optional
+        Pattern to filter results, in fnmatch format.
+
+    """
+    if isinstance(path, Path):
+        path = path.as_posix()
+
+    return ogr_vsi_listtree(path, pattern=pattern)
+
+
+def vsi_rmtree(path: Union[str, Path]):
+    """Recursively remove VSI directory.
+
+    Parameters
+    ----------
+    path : str or pathlib.Path
+        path to the VSI directory to be removed.
+
+    """
+    if isinstance(path, Path):
+        path = path.as_posix()
+
+    ogr_vsi_rmtree(path)
+
+
+def vsi_unlink(path: Union[str, Path]):
+    """Remove a VSI file.
+
+    Parameters
+    ----------
+    path : str or pathlib.Path
+        path to vsimem file to be removed
+
+    """
+    if isinstance(path, Path):
+        path = path.as_posix()
+
+    ogr_vsi_unlink(path)

pyogrio/errors.py

@@ -0,0 +1,25 @@
+"""Custom errors."""
+
+
+class DataSourceError(RuntimeError):
+    """Errors relating to opening or closing an OGRDataSource (with >= 1 layers)."""
+
+
+class DataLayerError(RuntimeError):
+    """Errors relating to working with a single OGRLayer."""
+
+
+class CRSError(DataLayerError):
+    """Errors relating to getting or setting CRS values."""
+
+
+class FeatureError(DataLayerError):
+    """Errors related to reading or writing a feature."""
+
+
+class GeometryError(DataLayerError):
+    """Errors relating to getting or setting a geometry field."""
+
+
+class FieldError(DataLayerError):
+    """Errors relating to getting or setting a non-geometry field."""

pyogrio/gdal_data/GDAL-targets-release.cmake

@@ -0,0 +1,20 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "GDAL::GDAL" for configuration "Release"
+set_property(TARGET GDAL::GDAL APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(GDAL::GDAL PROPERTIES
+  IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/gdal.lib"
+  IMPORTED_LINK_DEPENDENT_LIBRARIES_RELEASE "json-c::json-c;GEOS::geos_c;PROJ::proj;Qhull::qhull_r;expat::expat;geotiff_library"
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/gdal.dll"
+  )
+
+list(APPEND _cmake_import_check_targets GDAL::GDAL )
+list(APPEND _cmake_import_check_files_for_GDAL::GDAL "${_IMPORT_PREFIX}/lib/gdal.lib" "${_IMPORT_PREFIX}/bin/gdal.dll" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)

pyogrio/gdal_data/GDAL-targets.cmake

@@ -0,0 +1,105 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...3.28)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS GDAL::GDAL)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target GDAL::GDAL
+add_library(GDAL::GDAL SHARED IMPORTED)
+
+set_target_properties(GDAL::GDAL PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/GDAL-targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

pyogrio/gdal_data/GDALConfig.cmake

@@ -0,0 +1,23 @@
+cmake_policy(SET CMP0012 NEW)
+cmake_policy(SET CMP0057 NEW)
+if(NOT "ON")
+    if(NOT CMAKE_CXX_COMPILER_LOADED)
+        message(WARNING "Linking to GDAL may need CXX to be enabled.")
+    endif()
+    if(DEFINED CMAKE_MODULE_PATH)
+        set(_gdal_module_path_backup "${CMAKE_MODULE_PATH}")
+    endif()
+    include(CMakeFindDependencyMacro)
+# gdal needs a pkg-config tool. A host dependency provides pkgconf.
+get_filename_component(vcpkg_host_prefix "${CMAKE_CURRENT_LIST_DIR}/../../../x64-windows" ABSOLUTE)
+list(APPEND CMAKE_PROGRAM_PATH "${vcpkg_host_prefix}/tools/pkgconf")
+include("${CMAKE_CURRENT_LIST_DIR}/DefineFindPackage2.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/GdalFindModulePath.cmake")
+
+    if(DEFINED _gdal_module_path_backup)
+        set(CMAKE_MODULE_PATH  "${_gdal_module_path_backup}")
+    else()
+        unset(CMAKE_MODULE_PATH)
+    endif()
+endif()
+include("${CMAKE_CURRENT_LIST_DIR}/GDAL-targets.cmake")

pyogrio/gdal_data/GDALConfigVersion.cmake

@@ -0,0 +1,85 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major and minor versions are the same as the current
+# one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "3.9.1")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("3.9.1" MATCHES "^([0-9]+)\\.([0-9]+)")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    set(CVF_VERSION_MINOR "${CMAKE_MATCH_2}")
+
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+    if(NOT CVF_VERSION_MINOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MINOR "${CVF_VERSION_MINOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "3.9.1")
+    set(CVF_VERSION_MINOR "")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major and minor versions
+    math (EXPR CVF_VERSION_MINOR_NEXT "${CVF_VERSION_MINOR} + 1")
+    if (NOT (PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+          AND PACKAGE_FIND_VERSION_MIN_MINOR STREQUAL CVF_VERSION_MINOR)
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE"
+            AND NOT (PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR
+              AND PACKAGE_FIND_VERSION_MAX_MINOR STREQUAL CVF_VERSION_MINOR))
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE"
+            AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL ${CVF_VERSION_MAJOR}.${CVF_VERSION_MINOR_NEXT})))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND PACKAGE_FIND_VERSION_MIN_MINOR STREQUAL CVF_VERSION_MINOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(NOT PACKAGE_FIND_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" PACKAGE_FIND_VERSION_MAJOR "${PACKAGE_FIND_VERSION_MAJOR}")
+    endif()
+    if(NOT PACKAGE_FIND_VERSION_MINOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" PACKAGE_FIND_VERSION_MINOR "${PACKAGE_FIND_VERSION_MINOR}")
+    endif()
+
+    if((PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) AND
+        (PACKAGE_FIND_VERSION_MINOR STREQUAL CVF_VERSION_MINOR))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()