pygeodiff 2.0.4__cp39-cp39-macosx_10_9_x86_64.whl

pygeodiff/__about__.py

@@ -0,0 +1,10 @@
+__title__ = "PyGeoDiff"
+__description__ = "Diff tool for geo-spatial data"
+__url__ = "https://github.com/MerginMaps/geodiff"
+# use scripts/update_version.py to update the version here and in other places at once
+__version__ = "2.0.4"
+__author__ = "Lutra Consulting Ltd."
+__author_email__ = "info@merginmaps.com"
+__maintainer__ = "Lutra Consulting Ltd."
+__license__ = "MIT"
+__copyright__ = "(c) 2019-2022 Lutra Consulting Ltd."

pygeodiff/__init__.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+"""
+    pygeodiff
+    -----------
+    This module provides tools for create diffs of geospatial data formats
+    :copyright: (c) 2019-2022 Lutra Consulting Ltd.
+    :license: MIT, see LICENSE for more details.
+"""
+
+from .main import GeoDiff
+from .geodifflib import (
+    GeoDiffLibError,
+    GeoDiffLibConflictError,
+    GeoDiffLibUnsupportedChangeError,
+    GeoDiffLibVersionError,
+    ChangesetEntry,
+    ChangesetReader,
+    UndefinedValue,
+)

pygeodiff/geodifflib.py

@@ -0,0 +1,718 @@
+# -*- coding: utf-8 -*-
+"""
+    pygeodiff.geodifflib
+    --------------------
+    This module provides wrapper of geodiff C library
+    :copyright: (c) 2019-2022 Lutra Consulting Ltd.
+    :license: MIT, see LICENSE for more details.
+"""
+
+import ctypes
+import os
+import platform
+from ctypes.util import find_library
+from .__about__ import __version__
+import copy
+
+
+class GeoDiffLibError(Exception):
+    pass
+
+
+class GeoDiffLibConflictError(GeoDiffLibError):
+    pass
+
+
+class GeoDiffLibUnsupportedChangeError(GeoDiffLibError):
+    pass
+
+
+class GeoDiffLibVersionError(GeoDiffLibError):
+    pass
+
+
+# keep in sync with c-library
+SUCCESS = 0
+ERROR = 1
+CONFLICT = 2
+UNSUPPORTED_CHANGE = 3
+
+
+def _parse_return_code(rc, msg):
+    if rc == SUCCESS:
+        return
+    elif rc == ERROR:
+        raise GeoDiffLibError(msg)
+    elif rc == CONFLICT:
+        raise GeoDiffLibConflictError(msg)
+    elif rc == UNSUPPORTED_CHANGE:
+        raise GeoDiffLibUnsupportedChangeError(msg)
+    else:
+        raise GeoDiffLibVersionError(
+            "Internal error (enum " + str(rc) + " not handled)"
+        )
+
+
+class GeoDiffLib:
+    def __init__(self, name):
+        self.context = None
+        if name is None:
+            self.libname = self.package_libname()
+            if not os.path.exists(self.libname):
+                # not found, try system library
+                self.libname = find_library("geodiff")
+        else:
+            self.libname = name
+
+        if self.libname is None:
+            raise GeoDiffLibVersionError(
+                "Unable to locate GeoDiff library, tried "
+                + self.package_libname()
+                + " and geodiff on system."
+            )
+
+        try:
+            self.lib = ctypes.CDLL(self.libname, use_errno=True)
+        except OSError:
+            raise GeoDiffLibVersionError(
+                "Unable to load geodiff library " + self.libname
+            )
+        self.context = self.init()
+        self.callbackLogger = None
+        if self.context is None:
+            raise GeoDiffLibVersionError("Unable to create GeoDiff context")
+
+        self.check_version()
+        self._register_functions()
+
+    def __del__(self):
+        if self.context is not None:
+            func = self.lib.GEODIFF_CX_destroy
+            func.argtypes = [ctypes.c_void_p]
+            func(self.context)
+            self.context = None
+
+    def _register_functions(self):
+        self._readChangeset = self.lib.GEODIFF_readChangeset
+        self._readChangeset.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        self._readChangeset.restype = ctypes.c_void_p
+
+        # ChangesetReader
+        self._CR_nextEntry = self.lib.GEODIFF_CR_nextEntry
+        self._CR_nextEntry.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_void_p,
+            ctypes.c_void_p,
+        ]
+        self._CR_nextEntry.restype = ctypes.c_void_p
+
+        self._CR_destroy = self.lib.GEODIFF_CR_destroy
+        self._CR_destroy.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+
+        # ChangesetEntry
+        self._CE_operation = self.lib.GEODIFF_CE_operation
+        self._CE_operation.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._CE_operation.restype = ctypes.c_int
+
+        self._CE_table = self.lib.GEODIFF_CE_table
+        self._CE_table.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._CE_table.restype = ctypes.c_void_p
+
+        self._CE_count = self.lib.GEODIFF_CE_countValues
+        self._CE_count.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._CE_count.restype = ctypes.c_int
+
+        self._CE_old_value = self.lib.GEODIFF_CE_oldValue
+        self._CE_old_value.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int]
+        self._CE_old_value.restype = ctypes.c_void_p
+
+        self._CE_new_value = self.lib.GEODIFF_CE_newValue
+        self._CE_new_value.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int]
+        self._CE_new_value.restype = ctypes.c_void_p
+
+        self._CE_destroy = self.lib.GEODIFF_CE_destroy
+        self._CE_destroy.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+
+        # ChangesetTable
+        self._CT_name = self.lib.GEODIFF_CT_name
+        self._CT_name.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._CT_name.restype = ctypes.c_char_p
+
+        self._CT_column_count = self.lib.GEODIFF_CT_columnCount
+        self._CT_column_count.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._CT_column_count.restype = ctypes.c_int
+
+        self._CT_column_is_pkey = self.lib.GEODIFF_CT_columnIsPkey
+        self._CT_column_is_pkey.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_void_p,
+            ctypes.c_int,
+        ]
+        self._CT_column_is_pkey.restype = ctypes.c_bool
+
+        # Value
+        self._V_type = self.lib.GEODIFF_V_type
+        self._V_type.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._V_type.restype = ctypes.c_int
+
+        self._V_get_int = self.lib.GEODIFF_V_getInt
+        self._V_get_int.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._V_get_int.restype = ctypes.c_int
+
+        self._V_get_double = self.lib.GEODIFF_V_getDouble
+        self._V_get_double.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._V_get_double.restype = ctypes.c_double
+
+        self._V_get_data_size = self.lib.GEODIFF_V_getDataSize
+        self._V_get_data_size.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        self._V_get_data_size.restype = ctypes.c_int
+
+        self._V_get_data = self.lib.GEODIFF_V_getData
+        self._V_get_data.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p]
+
+        self._V_destroy = self.lib.GEODIFF_V_destroy
+        self._V_destroy.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+
+    def package_libname(self):
+        # assume that the package is installed through PIP
+        if platform.system() == "Windows":
+            prefix = ""
+            arch = platform.architecture()[0]  # 64bit or 32bit
+            if "32" in arch:
+                suffix = "-win32.pyd"
+            else:
+                suffix = ".pyd"
+        elif platform.system() == "Darwin":
+            prefix = "lib"
+            suffix = ".dylib"
+        else:
+            prefix = "lib"
+            suffix = ".so"
+        whl_lib = prefix + "pygeodiff-" + __version__ + "-python" + suffix
+        dir_path = os.path.dirname(os.path.realpath(__file__))
+        return os.path.join(dir_path, whl_lib)
+
+    def init(self):
+        func = self.lib.GEODIFF_createContext
+        func.restype = ctypes.c_void_p
+        return func()
+
+    def set_logger_callback(self, callback):
+        func = self.lib.GEODIFF_CX_setLoggerCallback
+        cFuncType = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
+        func.argtypes = [ctypes.c_void_p, cFuncType]
+        if callback:
+            # do not remove self, callback needs to be member
+            self.callbackLogger = cFuncType(callback)
+        else:
+            self.callbackLogger = cFuncType()
+        func(self.context, self.callbackLogger)
+
+    def set_maximum_logger_level(self, maxLevel):
+        func = self.lib.GEODIFF_CX_setMaximumLoggerLevel
+        func.argtypes = [ctypes.c_void_p, ctypes.c_int]
+        func(self.context, maxLevel)
+
+    def set_tables_to_skip(self, tables):
+        # make array of char* with utf-8 encoding from python list of strings
+        arr = (ctypes.c_char_p * len(tables))()
+        for i in range(len(tables)):
+            arr[i] = tables[i].encode("utf-8")
+
+        self.lib.GEODIFF_CX_setTablesToSkip(
+            ctypes.c_void_p(self.context), ctypes.c_int(len(tables)), arr
+        )
+
+    def version(self):
+        func = self.lib.GEODIFF_version
+        func.restype = ctypes.c_char_p
+        ver = func()
+        return ver.decode("utf-8")
+
+    def check_version(self):
+        cversion = self.version()
+        pyversion = __version__
+        if cversion != pyversion:
+            raise GeoDiffLibVersionError(
+                "version mismatch ({} C vs {} PY)".format(cversion, pyversion)
+            )
+
+    def drivers(self):
+        _driver_count_f = self.lib.GEODIFF_driverCount
+        _driver_count_f.argtypes = [ctypes.c_void_p]
+        _driver_count_f.restype = ctypes.c_int
+
+        _driver_name_from_index_f = self.lib.GEODIFF_driverNameFromIndex
+        _driver_name_from_index_f.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_int,
+            ctypes.c_char_p,
+        ]
+        _driver_name_from_index_f.restype = ctypes.c_int
+
+        drivers_list = []
+        driversCount = _driver_count_f(self.context)
+        for index in range(driversCount):
+            name_raw = 256 * ""
+            b_string1 = name_raw.encode("utf-8")
+            res = _driver_name_from_index_f(self.context, index, b_string1)
+            _parse_return_code(res, "drivers")
+            name = b_string1.decode("utf-8")
+            drivers_list.append(name)
+
+        return drivers_list
+
+    def driver_is_registered(self, name):
+        func = self.lib.GEODIFF_driverIsRegistered
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        func.restype = ctypes.c_bool
+
+        b_string1 = name.encode("utf-8")
+        return func(self.context, b_string1)
+
+    def create_changeset(self, base, modified, changeset):
+        func = self.lib.GEODIFF_createChangeset
+        func.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+        ]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = base.encode("utf-8")
+        b_string2 = modified.encode("utf-8")
+        b_string3 = changeset.encode("utf-8")
+
+        res = func(self.context, b_string1, b_string2, b_string3)
+        _parse_return_code(res, "createChangeset")
+
+    def invert_changeset(self, changeset, changeset_inv):
+        func = self.lib.GEODIFF_invertChangeset
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = changeset.encode("utf-8")
+        b_string2 = changeset_inv.encode("utf-8")
+
+        res = func(self.context, b_string1, b_string2)
+        _parse_return_code(res, "invert_changeset")
+
+    def create_rebased_changeset(
+        self, base, modified, changeset_their, changeset, conflict
+    ):
+        func = self.lib.GEODIFF_createRebasedChangeset
+        func.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+        ]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = base.encode("utf-8")
+        b_string2 = modified.encode("utf-8")
+        b_string3 = changeset_their.encode("utf-8")
+        b_string4 = changeset.encode("utf-8")
+        b_string5 = conflict.encode("utf-8")
+
+        res = func(self.context, b_string1, b_string2, b_string3, b_string4, b_string5)
+        _parse_return_code(res, "createRebasedChangeset")
+
+    def rebase(self, base, modified_their, modified, conflict):
+        func = self.lib.GEODIFF_rebase
+        func.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+        ]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = base.encode("utf-8")
+        b_string2 = modified_their.encode("utf-8")
+        b_string3 = modified.encode("utf-8")
+        b_string4 = conflict.encode("utf-8")
+        res = func(self.context, b_string1, b_string2, b_string3, b_string4)
+        _parse_return_code(res, "rebase")
+
+    def apply_changeset(self, base, changeset):
+        func = self.lib.GEODIFF_applyChangeset
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = base.encode("utf-8")
+        b_string2 = changeset.encode("utf-8")
+
+        res = func(self.context, b_string1, b_string2)
+        _parse_return_code(res, "apply_changeset")
+
+    def list_changes(self, changeset, result):
+        func = self.lib.GEODIFF_listChanges
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = changeset.encode("utf-8")
+        b_string2 = result.encode("utf-8")
+        res = func(self.context, b_string1, b_string2)
+        _parse_return_code(res, "list_changes")
+
+    def list_changes_summary(self, changeset, result):
+        func = self.lib.GEODIFF_listChangesSummary
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = changeset.encode("utf-8")
+        b_string2 = result.encode("utf-8")
+        res = func(self.context, b_string1, b_string2)
+        _parse_return_code(res, "list_changes_summary")
+
+    def has_changes(self, changeset):
+        func = self.lib.GEODIFF_hasChanges
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = changeset.encode("utf-8")
+
+        nchanges = func(self.context, b_string1)
+        if nchanges < 0:
+            raise GeoDiffLibError("has_changes")
+        return nchanges == 1
+
+    def changes_count(self, changeset):
+        func = self.lib.GEODIFF_changesCount
+        func.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+        func.restype = ctypes.c_int
+
+        # create byte objects from the strings
+        b_string1 = changeset.encode("utf-8")
+
+        nchanges = func(self.context, b_string1)
+        if nchanges < 0:
+            raise GeoDiffLibError("changes_count")
+        return nchanges
+
+    def concat_changes(self, list_changesets, output_changeset):
+        # make array of char* with utf-8 encoding from python list of strings
+        arr = (ctypes.c_char_p * len(list_changesets))()
+        for i in range(len(list_changesets)):
+            arr[i] = list_changesets[i].encode("utf-8")
+
+        res = self.lib.GEODIFF_concatChanges(
+            ctypes.c_void_p(self.context),
+            ctypes.c_int(len(list_changesets)),
+            arr,
+            ctypes.c_char_p(output_changeset.encode("utf-8")),
+        )
+        _parse_return_code(res, "concat_changes")
+
+    def make_copy(
+        self, driver_src, driver_src_info, src, driver_dst, driver_dst_info, dst
+    ):
+        res = self.lib.GEODIFF_makeCopy(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver_src.encode("utf-8")),
+            ctypes.c_char_p(driver_src_info.encode("utf-8")),
+            ctypes.c_char_p(src.encode("utf-8")),
+            ctypes.c_char_p(driver_dst.encode("utf-8")),
+            ctypes.c_char_p(driver_dst_info.encode("utf-8")),
+            ctypes.c_char_p(dst.encode("utf-8")),
+        )
+        _parse_return_code(res, "make_copy")
+
+    def make_copy_sqlite(self, src, dst):
+        res = self.lib.GEODIFF_makeCopySqlite(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(src.encode("utf-8")),
+            ctypes.c_char_p(dst.encode("utf-8")),
+        )
+        _parse_return_code(res, "make_copy_sqlite")
+
+    def create_changeset_ex(self, driver, driver_info, base, modified, changeset):
+        res = self.lib.GEODIFF_createChangesetEx(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(base.encode("utf-8")),
+            ctypes.c_char_p(modified.encode("utf-8")),
+            ctypes.c_char_p(changeset.encode("utf-8")),
+        )
+        _parse_return_code(res, "create_changeset_ex")
+
+    def create_changeset_dr(
+        self,
+        driver_src,
+        driver_src_info,
+        src,
+        driver_dst,
+        driver_dst_info,
+        dst,
+        changeset,
+    ):
+        func = self.lib.GEODIFF_createChangesetDr
+        func.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+        ]
+        func.restype = ctypes.c_int
+
+        b_string1 = driver_src.encode("utf-8")
+        b_string2 = driver_src_info.encode("utf-8")
+        b_string3 = src.encode("utf-8")
+        b_string4 = driver_dst.encode("utf-8")
+        b_string5 = driver_dst_info.encode("utf-8")
+        b_string6 = dst.encode("utf-8")
+        b_string7 = changeset.encode("utf-8")
+
+        res = func(
+            self.context,
+            b_string1,
+            b_string2,
+            b_string3,
+            b_string4,
+            b_string5,
+            b_string6,
+            b_string7,
+        )
+        _parse_return_code(res, "CreateChangesetDr")
+
+    def apply_changeset_ex(self, driver, driver_info, base, changeset):
+        res = self.lib.GEODIFF_applyChangesetEx(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(base.encode("utf-8")),
+            ctypes.c_char_p(changeset.encode("utf-8")),
+        )
+        _parse_return_code(res, "apply_changeset_ex")
+
+    def create_rebased_changeset_ex(
+        self,
+        driver,
+        driver_info,
+        base,
+        base2modified,
+        base2their,
+        rebased,
+        conflict_file,
+    ):
+        res = self.lib.GEODIFF_createRebasedChangesetEx(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(base.encode("utf-8")),
+            ctypes.c_char_p(base2modified.encode("utf-8")),
+            ctypes.c_char_p(base2their.encode("utf-8")),
+            ctypes.c_char_p(rebased.encode("utf-8")),
+            ctypes.c_char_p(conflict_file.encode("utf-8")),
+        )
+        _parse_return_code(res, "create_rebased_changeset_ex")
+
+    def rebase_ex(self, driver, driver_info, base, modified, base2their, conflict_file):
+        res = self.lib.GEODIFF_rebaseEx(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(base.encode("utf-8")),
+            ctypes.c_char_p(modified.encode("utf-8")),
+            ctypes.c_char_p(base2their.encode("utf-8")),
+            ctypes.c_char_p(conflict_file.encode("utf-8")),
+        )
+        _parse_return_code(res, "rebase_ex")
+
+    def dump_data(self, driver, driver_info, src, changeset):
+        res = self.lib.GEODIFF_dumpData(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(src.encode("utf-8")),
+            ctypes.c_char_p(changeset.encode("utf-8")),
+        )
+        _parse_return_code(res, "dump_data")
+
+    def schema(self, driver, driver_info, src, json):
+        res = self.lib.GEODIFF_schema(
+            ctypes.c_void_p(self.context),
+            ctypes.c_char_p(driver.encode("utf-8")),
+            ctypes.c_char_p(driver_info.encode("utf-8")),
+            ctypes.c_char_p(src.encode("utf-8")),
+            ctypes.c_char_p(json.encode("utf-8")),
+        )
+        _parse_return_code(res, "schema")
+
+    def read_changeset(self, changeset):
+
+        b_string1 = changeset.encode("utf-8")
+
+        reader_ptr = self._readChangeset(self.context, b_string1)
+        if reader_ptr is None:
+            raise GeoDiffLibError("Unable to open reader for: " + changeset)
+        return ChangesetReader(self, reader_ptr)
+
+    def create_wkb_from_gpkg_header(self, geometry):
+        func = self.lib.GEODIFF_createWkbFromGpkgHeader
+        func.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_char),
+            ctypes.c_size_t,
+            ctypes.POINTER(ctypes.POINTER(ctypes.c_char)),
+            ctypes.POINTER(ctypes.c_size_t),
+        ]
+        func.restype = ctypes.c_int
+
+        out = ctypes.POINTER(ctypes.c_char)()
+        out_size = ctypes.c_size_t(len(geometry))
+        res = func(
+            self.context,
+            geometry,
+            ctypes.c_size_t(len(geometry)),
+            ctypes.byref(out),
+            ctypes.byref(out_size),
+        )
+        _parse_return_code(res, "create_wkb_from_gpkg_header")
+        wkb = copy.deepcopy(out[: out_size.value])
+        return wkb
+
+
+class ChangesetReader(object):
+    """Wrapper around GEODIFF_CR_* functions from C API"""
+
+    def __init__(self, geodiff, reader_ptr):
+        self.geodiff = geodiff
+        self.reader_ptr = reader_ptr
+
+    def __del__(self):
+        self.geodiff._CR_destroy(self.geodiff.context, self.reader_ptr)
+
+    def next_entry(self):
+        ok = ctypes.c_bool()
+        entry_ptr = self.geodiff._CR_nextEntry(
+            self.geodiff.context, self.reader_ptr, ctypes.byref(ok)
+        )
+        if not ok:
+            raise GeoDiffLibError("Failed to read entry!")
+        if entry_ptr is not None:
+            return ChangesetEntry(self.geodiff, entry_ptr)
+        else:
+            return None
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        entry = self.next_entry()
+        if entry is not None:
+            return entry
+        else:
+            raise StopIteration
+
+    next = __next__  # python 2.x compatibility (requires next())
+
+
+class ChangesetEntry(object):
+    """Wrapper around GEODIFF_CE_* functions from C API"""
+
+    # constants as defined in ChangesetEntry::OperationType enum
+    OP_INSERT = 18
+    OP_UPDATE = 23
+    OP_DELETE = 9
+
+    def __init__(self, geodiff, entry_ptr):
+        self.geodiff = geodiff
+        self.entry_ptr = entry_ptr
+
+        self.operation = self.geodiff._CE_operation(
+            self.geodiff.context, self.entry_ptr
+        )
+        self.values_count = self.geodiff._CE_count(self.geodiff.context, self.entry_ptr)
+
+        if self.operation == self.OP_DELETE or self.operation == self.OP_UPDATE:
+            self.old_values = []
+            for i in range(self.values_count):
+                v_ptr = self.geodiff._CE_old_value(
+                    self.geodiff.context, self.entry_ptr, i
+                )
+                self.old_values.append(self._convert_value(v_ptr))
+
+        if self.operation == self.OP_INSERT or self.operation == self.OP_UPDATE:
+            self.new_values = []
+            for i in range(self.values_count):
+                v_ptr = self.geodiff._CE_new_value(
+                    self.geodiff.context, self.entry_ptr, i
+                )
+                self.new_values.append(self._convert_value(v_ptr))
+
+        table = self.geodiff._CE_table(self.geodiff.context, entry_ptr)
+        self.table = ChangesetTable(geodiff, table)
+
+    def __del__(self):
+        self.geodiff._CE_destroy(self.geodiff.context, self.entry_ptr)
+
+    def _convert_value(self, v_ptr):
+        v_type = self.geodiff._V_type(self.geodiff.context, v_ptr)
+        if v_type == 0:
+            v_val = UndefinedValue()
+        elif v_type == 1:
+            v_val = self.geodiff._V_get_int(self.geodiff.context, v_ptr)
+        elif v_type == 2:
+            v_val = self.geodiff._V_get_double(self.geodiff.context, v_ptr)
+        elif v_type == 3 or v_type == 4:  # 3==text, 4==blob
+            size = self.geodiff._V_get_data_size(self.geodiff.context, v_ptr)
+            buffer = ctypes.create_string_buffer(size)
+            self.geodiff._V_get_data(self.geodiff.context, v_ptr, buffer)
+            v_val = buffer.raw
+            if v_type == 3:
+                v_val = v_val.decode("utf-8")
+        elif v_type == 5:
+            v_val = None
+        else:
+            raise GeoDiffLibError("unknown value type {}".format(v_type))
+        self.geodiff._V_destroy(self.geodiff.context, v_ptr)
+        return v_val
+
+
+class ChangesetTable(object):
+    """Wrapper around GEODIFF_CT_* functions from C API"""
+
+    def __init__(self, geodiff, table_ptr):
+        self.geodiff = geodiff
+        self.table_ptr = table_ptr
+
+        self.name = self.geodiff._CT_name(self.geodiff.context, table_ptr).decode(
+            "utf-8"
+        )
+        self.column_count = self.geodiff._CT_column_count(
+            self.geodiff.context, table_ptr
+        )
+        self.column_is_pkey = []
+        for i in range(self.column_count):
+            self.column_is_pkey.append(
+                self.geodiff._CT_column_is_pkey(self.geodiff.context, table_ptr, i)
+            )
+
+
+class UndefinedValue(object):
+    """Marker that a value in changeset is undefined. This is different
+    from NULL value (which is represented as None). Undefined values are
+    used for example as values of columns in UPDATE operation that did
+    not get modified."""
+
+    def __repr__(self):
+        return "<N/A>"

pygeodiff/main.py

@@ -0,0 +1,390 @@
+# -*- coding: utf-8 -*-
+"""
+    pygeodiff.main
+    --------------
+    Main entry of the library
+    :copyright: (c) 2019-2022 Lutra Consulting Ltd.
+    :license: MIT, see LICENSE for more details.
+"""
+
+from .geodifflib import GeoDiffLib
+
+
+class GeoDiff:
+    """
+    geodiff is a module to create and apply changesets to GIS files (geopackage)
+    """
+
+    def __init__(self, libname=None):
+        """
+        if libname is None, it tries to import c-extension from wheel
+        messages are shown in stdout/stderr.
+        Use environment variable GEODIFF_LOGGER_LEVEL 0(Nothing)-4(Debug) to
+        set level (Errors by default)
+        """
+        self.clib = GeoDiffLib(libname)
+
+    def set_logger_callback(self, callback):
+        """
+        Assign custom logger
+        Replace default stdout/stderr logger with custom.
+        When callback is None, no output is produced at all
+        Callback function has 2 arguments: (int) errorCode, (string) msg
+        """
+        return self.clib.set_logger_callback(callback)
+
+    def set_tables_to_skip(self, tables):
+        """
+        Set list of tables to exclude from geodiff operations. Once defined, these
+        tables will be excluded from the following operations: create changeset,
+        apply changeset, rebase, get database schema, dump database contents, copy
+        database between different drivers.
+
+        If empty list is passed, skip tables list will be reset.
+        """
+        return self.clib.set_tables_to_skip(tables)
+
+    LevelError = 1
+    LevelWarning = 2
+    LevelInfo = 3
+    LevelDebug = 4
+
+    def set_maximum_logger_level(self, maxLevel):
+        """
+        Assign maximum level of messages that are passed to logger callbac
+        Based on maxLogLevel, the messages are filtered by level:
+        maxLogLevel = 0 nothing is passed to logger callback
+        maxLogLevel = 1 errors are passed to logger callback
+        maxLogLevel = 2 errors and warnings are passed to logger callback
+        maxLogLevel = 3 errors, warnings and infos are passed to logger callback
+        maxLogLevel = 4 errors, warnings, infos, debug messages are passed to logger callback
+        """
+        return self.clib.set_maximum_logger_level(maxLevel)
+
+    def drivers(self):
+        """
+        Returns list of registered drivers (e.g. ["sqlite", "postgresql"])
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.drivers()
+
+    def driver_is_registered(self, name):
+        """
+        Returns whether dataset with given name is registered (e.g. "sqlite" or "postgresql")
+        """
+        return self.clib.driver_is_registered(name)
+
+    def create_changeset(self, base, modified, changeset):
+        """
+        Creates changeset file (binary) in such way that
+        if CHANGESET is applied to BASE by applyChangeset,
+        MODIFIED will be created
+
+        BASE --- CHANGESET ---> MODIFIED
+
+        \param base [input] BASE sqlite3/geopackage file
+        \param modified [input] MODIFIED sqlite3/geopackage file
+        \param changeset [output] changeset between BASE -> MODIFIED
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.create_changeset(base, modified, changeset)
+
+    def invert_changeset(self, changeset, changeset_inv):
+        """
+        Inverts changeset file (binary) in such way that
+        if CHANGESET_INV is applied to MODIFIED by applyChangeset,
+        BASE will be created
+
+        \param changeset [input] changeset between BASE -> MODIFIED
+        \param changeset_inv [output] changeset between MODIFIED -> BASE
+
+        \returns number of conflics
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.invert_changeset(changeset, changeset_inv)
+
+    def rebase(self, base, modified_their, modified, conflict):
+        """
+        Rebases local modified version from base to modified_their version
+
+               --- > MODIFIED_THEIR
+        BASE -|
+               ----> MODIFIED (local) ---> MODIFIED_THEIR_PLUS_MINE
+
+        Steps performed on MODIFIED (local) file:
+        1. undo local changes MODIFIED -> BASE
+        2. apply changes from MODIFIED_THEIR
+        3. apply rebased local changes and create MODIFIED_THEIR_PLUS_MINE
+
+        Note, when rebase is not successfull, modified could be in random state.
+        This works in general, even when base==modified, or base==modified_theirs
+
+         \param base [input] BASE sqlite3/geopackage file
+         \param modified_their [input] MODIFIED sqlite3/geopackage file
+         \param modified [input] local copy of the changes to be rebased
+         \param conflict [output] file where the automatically resolved conflicts are stored. If there are no conflicts, file is not created
+
+         raises GeoDiffLibError on error
+        """
+        return self.clib.rebase(base, modified_their, modified, conflict)
+
+    def create_rebased_changeset(
+        self, base, modified, changeset_their, changeset, conflict
+    ):
+        """
+        Creates changeset file (binary) in such way that
+        if CHANGESET is applied to MODIFIED_THEIR by
+        applyChangeset, the new state will contain all
+        changes from MODIFIED and MODIFIED_THEIR.
+
+               --- CHANGESET_THEIR ---> MODIFIED_THEIR --- CHANGESET ---> MODIFIED_THEIR_PLUS_MINE
+        BASE -|
+               -----------------------> MODIFIED
+
+         \param base [input] BASE sqlite3/geopackage file
+         \param modified [input] MODIFIED sqlite3/geopackage file
+         \param changeset_their [input] changeset between BASE -> MODIFIED_THEIR
+         \param changeset [output] changeset between MODIFIED_THEIR -> MODIFIED_THEIR_PLUS_MINE
+         \param conflict [output] file where the automatically resolved conflicts are stored. If there are no conflicts, file is not created
+
+         raises GeoDiffLibError on error
+        """
+        return self.clib.create_rebased_changeset(
+            base, modified, changeset_their, changeset, conflict
+        )
+
+    def apply_changeset(self, base, changeset):
+        """
+        Applies changeset file (binary) to BASE
+
+        \param base [input/output] BASE sqlite3/geopackage file
+        \param changeset [input] changeset to apply to BASE
+        \returns number of conflicts
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.apply_changeset(base, changeset)
+
+    def list_changes(self, changeset, json):
+        """
+        Lists changeset content JSON file
+        JSON contains all changes in human/machine readable name
+        \returns number of changes
+
+         raises GeoDiffLibError on error
+        """
+        return self.clib.list_changes(changeset, json)
+
+    def list_changes_summary(self, changeset, json):
+        """
+        Lists changeset summary content JSON file
+        JSON contains a list of how many inserts/edits/deletes is contained in changeset for each table
+        \returns number of changes
+
+         raises GeoDiffLibError on error
+        """
+        return self.clib.list_changes_summary(changeset, json)
+
+    def has_changes(self, changeset):
+        """
+        \returns whether changeset contains at least one change
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.has_changes(changeset)
+
+    def changes_count(self, changeset):
+        """
+        \returns number of changes
+
+         raises GeoDiffLibError on error
+        """
+        return self.clib.changes_count(changeset)
+
+    def concat_changes(self, list_changesets, output_changeset):
+        """
+        Combine multiple changeset files into a single changeset file. When the output changeset
+        is applied to a database, the result should be the same as if the input changesets were applied
+        one by one. The order of input files is important. At least two input files need to be
+        provided.
+
+        Incompatible changes (which would cause conflicts when applied) will be discarded.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.concat_changes(list_changesets, output_changeset)
+
+    def make_copy(
+        self, driver_src, driver_src_info, src, driver_dst, driver_dst_info, dst
+    ):
+        """
+        Makes a copy of the source dataset (a collection of tables) to the specified destination.
+
+        This will open the source dataset, get list of tables, their structure, dump data
+        to a temporary changeset file. Then it will create the destination dataset, create tables
+        and insert data from changeset file.
+
+        Supported drivers:
+
+        - "sqlite" - does not need extra connection info (may be null). A dataset is a single Sqlite3
+        database (a GeoPackage) - a path to a local file is expected.
+
+        - "postgres" - only available if compiled with postgres support. Needs extra connection info
+        argument which is passed to libpq's PQconnectdb(), see PostgreSQL docs for syntax.
+        A datasource identifies a PostgreSQL schema name (namespace) within the current database.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.make_copy(
+            driver_src, driver_src_info, src, driver_dst, driver_dst_info, dst
+        )
+
+    def make_copy_sqlite(self, src, dst):
+        """
+        Makes a copy of a SQLite database. If the destination database file exists, it will be overwritten.
+
+        This is the preferred way of copying SQLite/GeoPackage files compared to just using raw copying
+        of files on the file system: it will take into account other readers/writers and WAL file,
+        so we should never end up with a corrupt copy.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.make_copy_sqlite(src, dst)
+
+    def create_changeset_ex(self, driver, driver_info, base, modified, changeset):
+        """
+        This is an extended version of create_changeset() which also allows specification
+        of the driver and its extra connection info. The original create_changeset() function
+        only supports Sqlite driver.
+
+        See documentation of make_copy() for details about supported drivers.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.create_changeset_ex(
+            driver, driver_info, base, modified, changeset
+        )
+
+    def create_changeset_dr(
+        self,
+        driver_src,
+        driver_src_info,
+        src,
+        driver_dst,
+        driver_dst_info,
+        dst,
+        changeset,
+    ):
+        """
+        Creates changeset file (binary) between src and dest for different drivers.
+        Currently supported drivers:
+         - sqlite
+         - postgres
+
+        See documentation of create_changeset for more information about changeset.
+
+        \param driver_src [input] driver of base src
+        \param driver_src_info [input] connection string, leave empty for sqlite, for postgres pass a string of format:
+        "host=<host> port=<port> user=<user> password=<password> dbname=<database name>"
+        \param src [input] BASE sqlite3/geopackage file for sqlite and schema name for postgres
+        \param driver_dst [input] driver of modified dst
+        \param driver_dst_info [input] connection string for destination driver
+        \param dst [input] MODIFIED sqlite3/geopackage file for sqlite and schema name for postgres
+        \param changeset [output] changeset between SRC -> DST
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.create_changeset_dr(
+            driver_src,
+            driver_src_info,
+            src,
+            driver_dst,
+            driver_dst_info,
+            dst,
+            changeset,
+        )
+
+    def apply_changeset_ex(self, driver, driver_info, base, changeset):
+        """
+        This is an extended version of apply_changeset() which also allows specification
+        of the driver and its extra connection info. The original apply_changeset() function
+        only supports Sqlite driver.
+
+        See documentation of make_copy() for details about supported drivers.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.apply_changeset_ex(driver, driver_info, base, changeset)
+
+    def create_rebased_changeset_ex(
+        self,
+        driver,
+        driver_info,
+        base,
+        base2modified,
+        base2their,
+        rebased,
+        conflict_file,
+    ):
+        """
+        This function takes an existing changeset "base2modified" and rebases it on top of changes in
+        "base2their" and writes output to a new changeset "rebased"
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.create_rebased_changeset_ex(
+            driver, driver_info, base, base2modified, base2their, rebased, conflict_file
+        )
+
+    def rebase_ex(self, driver, driver_info, base, modified, base2their, conflict_file):
+        """
+        This function takes care of updating "modified" dataset by taking any changes between "base"
+        and "modified" datasets and rebasing them on top of base2their changeset.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.rebase_ex(
+            driver, driver_info, base, modified, base2their, conflict_file
+        )
+
+    def dump_data(self, driver, driver_info, src, changeset):
+        """
+        Dumps all data from the data source as INSERT statements to a new changeset file.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.dump_data(driver, driver_info, src, changeset)
+
+    def schema(self, driver, driver_info, src, json):
+        """
+        Writes a JSON file containing database schema of tables as understood by geodiff.
+
+        raises GeoDiffLibError on error
+        """
+        return self.clib.schema(driver, driver_info, src, json)
+
+    def read_changeset(self, changeset):
+        """
+        Opens a changeset file and returns reader object or raises GeoDiffLibError on error.
+        """
+        return self.clib.read_changeset(changeset)
+
+    def version(self):
+        """
+        geodiff version
+        """
+        return self.clib.version()
+
+    def create_wkb_from_gpkg_header(self, geometry):
+        """
+        Extracts geometry in WKB format from the geometry encoded according to GeoPackage spec
+        """
+        return self.clib.create_wkb_from_gpkg_header(geometry)
+
+
+def main():
+    diff_lib = GeoDiff()
+    print("pygeodiff " + diff_lib.version())

pygeodiff-2.0.4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Lutra Consulting Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pygeodiff-2.0.4.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: pygeodiff
+Version: 2.0.4
+Summary: Python wrapper around GeoDiff library
+Home-page: https://github.com/MerginMaps/geodiff
+Author: Lutra Consulting Ltd.
+Author-email: info@merginmaps.com
+License: License :: OSI Approved :: MIT License
+Keywords: diff,gis,geo,geopackage,merge
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+License-File: LICENSE
+
+Python wrapper around GeoDiff library

pygeodiff-2.0.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+pygeodiff/__init__.py,sha256=tNR2dfUOhbLnHY9BFg3SXsFqT-MVjU5WlSjePwFFaas,470
+pygeodiff/libpygeodiff-2.0.4-python.dylib,sha256=dxMQX0bKeCJ7_xR2bpiQvAOumQvX3IgHNaIPS6sZ3bg,528848
+pygeodiff/__about__.py,sha256=XRBs6-H8pn1zorWiCWgu5u1cBQwk1SCWmgaNiNEC-NI,427
+pygeodiff/geodifflib.py,sha256=BfAK0K4t7rMgJ13yiH1Zl1OPdUATu5JBzHTcn05NZ2E,25086
+pygeodiff/main.py,sha256=PE0dFuDfsMC2gVEjd5lEqjDdf7uHLh5DTdVIJzstgeQ,14423
+pygeodiff/.dylibs/libsqlite3.0.dylib,sha256=EuFr3TE5NVNAn3v_oZGQf5egds6bmegFQ_Y-FW0nrwo,1793696
+pygeodiff-2.0.4.dist-info/RECORD,,
+pygeodiff-2.0.4.dist-info/LICENSE,sha256=pPekwnp737i2BfjOCth9EjHA8ijKqgUqnZvXhSiy7rk,1078
+pygeodiff-2.0.4.dist-info/WHEEL,sha256=vmRTWwSr0k67XZG4u7Ipy0i2UTgz-efRH2vDqHyId_k,103
+pygeodiff-2.0.4.dist-info/entry_points.txt,sha256=RT77c6_7NNim8cyF-SS9JxyG_28rsFv-Me24fU2co7o,50
+pygeodiff-2.0.4.dist-info/top_level.txt,sha256=ndjfGeE8jGvELbnBQHaHjf13GDrUcOGA7V64GnQvFgc,10
+pygeodiff-2.0.4.dist-info/METADATA,sha256=JGHSMWwWACuAbCoMFBTzEhOc70wEBBGVrpgOkOhgtkk,433

pygeodiff-2.0.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: skbuild 0.18.1
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_10_9_x86_64
+

pygeodiff-2.0.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pygeodiff = pygeodiff.main:main

pygeodiff-2.0.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+pygeodiff