wowool-sdk-cpp 3.4.5__tar.gz

wowool_sdk_cpp-3.4.5/MANIFEST.in

@@ -0,0 +1,14 @@
+include wowool/plugin/wowool_plugin.hpp
+include sdk_version.txt
+include version.txt
+include install_requires.txt
+include install_requires_wowool.txt
+include pre_setup.py
+include common_setup.py
+global-exclude *.dylib
+global-exclude *.so
+global-exclude *.dll
+exclude wowool/package/lib/wow
+exclude wowool/package/lib/woc
+exclude wowool/package/lib/afst
+include long_description.md

wowool_sdk_cpp-3.4.5/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: wowool-sdk-cpp
+Version: 3.4.5
+Summary: Wowool NLP Toolkit C++ SDK Python Bindings
+Author: Wowool
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+Dynamic: summary
+
+# The Wowool NLP CPP Bindings
+
+## Introduction
+
+This package contains the cpp bindings of the wowool-sdk and should not be install as a separated package, install the wowool-sdk instead which contains this package.
+
+## License
+
+In both cases you will need to acquirer a license file at https://www.wowool.com
+
+### Non-Commercial
+
+    This library is licensed under the GNU AGPLv3 for non-commercial use.  
+    For commercial use, a separate license must be purchased.  
+
+### Commercial license Terms
+
+    1. Grants the right to use this library in proprietary software.  
+    2. Requires a valid license key  
+    3. Redistribution in SaaS requires a commercial license.  

wowool_sdk_cpp-3.4.5/common_setup.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+import os
+import shutil
+
+
+def copy_with_lnk(src, dst):
+    dst = Path(dst)
+    src = Path(src)
+
+    if os.path.islink(src):
+        linkto = os.readlink(src)
+
+        # Remove existing destination if it exists
+        if os.path.lexists(dst):
+            os.unlink(dst)
+
+        try:
+            # Try to determine if the link is relative or absolute
+            target_path = Path(linkto)
+            if not target_path.is_absolute():
+                # If relative, maintain the same relative path
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                dir_fd = os.open(dst.parent, os.O_RDONLY)
+                os.symlink(linkto, dst, dir_fd=dir_fd)
+                os.close(dir_fd)
+                if not os.path.islink(dst):
+                    raise RuntimeError(f"Failed to create symlink {dst} -> {linkto}")
+
+            else:
+                # If absolute, we need to determine the new absolute path
+                # or just copy the file directly as a fallback
+
+                target_file = src.parent / linkto if not os.path.isabs(linkto) else Path(linkto)
+                if target_file.exists():
+                    # Just copy the target file directly instead of creating a symlink
+                    shutil.copy2(target_file, dst)
+                else:
+                    # Create a symlink anyway, might work in some environments
+                    os.symlink(linkto, dst)
+
+        except Exception as ex:
+            print(f"Error creating symlink: {ex}")
+            raise ex
+    else:
+        # Regular file copy
+        shutil.copy2(src, dst)
+
+
+def copy_to_package_folder(site_packages: Path, wow_sdk_folder: Path, bin_folders: Path, inc_folders: Path, lib_folders: Path):
+    """
+    Copy the files to the package folder
+    """
+    print(f"[WOW]  site_packages: {site_packages=}")
+    try:
+        wowool_package_lib = site_packages / "wowool" / "package" / "lib"
+        print(f"[WOW]  wowool_package_lib: {wowool_package_lib=}")
+        wowool_package_lib.mkdir(parents=True, exist_ok=True)
+
+        for fn in bin_folders.glob("*"):
+            print(f"[WOW]  bin: {fn.name}")
+            copy_with_lnk(fn, wowool_package_lib / fn.name)
+
+        for fn in lib_folders.glob("*"):
+            copy_with_lnk(fn, wowool_package_lib / fn.name)
+
+        print(f"[WOW]  Folders : WOWOOL_STAGE: {wow_sdk_folder=} {inc_folders=} {lib_folders=}")
+        if lib_folders.exists() and inc_folders.exists():
+            os.environ["WOWOOL_STAGE"] = str(wow_sdk_folder)
+            # WOWOOL_STAGE = wow_sdk_folder
+            print("wowool.package folder:", wowool_package_lib)
+        else:
+            print(
+                """[WOWOOL] You will need to set the WOWOOL_STAGE folder, to build the native package.
+This should be in your environment ..../wowool/package"""
+            )
+            exit(-1)
+    except Exception as ex:
+        print(f"""[WOWOOL] {ex} Could not copy tile to stage folder""")
+        raise ex

wowool_sdk_cpp-3.4.5/long_description.md

@@ -0,0 +1,20 @@
+# The Wowool NLP CPP Bindings
+
+## Introduction
+
+This package contains the cpp bindings of the wowool-sdk and should not be install as a separated package, install the wowool-sdk instead which contains this package.
+
+## License
+
+In both cases you will need to acquirer a license file at https://www.wowool.com
+
+### Non-Commercial
+
+    This library is licensed under the GNU AGPLv3 for non-commercial use.  
+    For commercial use, a separate license must be purchased.  
+
+### Commercial license Terms
+
+    1. Grants the right to use this library in proprietary software.  
+    2. Requires a valid license key  
+    3. Redistribution in SaaS requires a commercial license.  

wowool_sdk_cpp-3.4.5/pre_setup.py

@@ -0,0 +1,241 @@
+import os
+import shutil
+from pathlib import Path
+import platform
+from logging import getLogger
+import subprocess
+import json
+
+logger = getLogger(__name__)
+
+this_dir = Path(__file__).parent
+fusion_root = None
+fusion_root = this_dir
+
+pi = platform.system()
+tar_ext = "tar.gz" if pi != "Windows" else "zip"
+app_ext = "" if pi != "Windows" else ".exe"
+SO_EXT = ".so" if pi != "Windows" else ".pyd"
+native_so_prefix = "lib" if pi != "Windows" else ""
+if pi == "Windows":
+    NATIVE_SO_EXT = ".dll"
+elif pi == "Darwin":
+    NATIVE_SO_EXT = ".dylib"
+else:
+    NATIVE_SO_EXT = ".so"
+
+
+def get_origin_keyword():
+    if platform.system() == "Darwin":
+        return "@loader_path"
+    elif platform.system() == "Linux":
+        return "$ORIGIN"
+
+
+def call_subprocess(cmd_params):
+    cmd = " ".join(cmd_params)
+    try:
+        subprocess.run(cmd, shell=True, check=True)
+    except subprocess.CalledProcessError as ex:
+        logger.exception(f"Cannot run [{cmd}], {ex}")
+
+
+def get_all_rpaths(filename):
+    if platform.system() == "Darwin":
+        cmd = ["otool", "-l", str(filename)]
+        if not filename.exists():
+            raise RuntimeError(f"File not there yet {filename}")
+        rpathlist = [line.strip() for line in subprocess.check_output(cmd).decode().split("\n")]
+        rpaths = []
+        pidx = -1
+        for idx, line in enumerate(rpathlist):
+            if line.startswith("cmd LC_RPATH"):
+                pidx = idx + 2
+            elif idx == pidx:
+                rpaths.append(line.split(" ")[1])
+        return rpaths
+    else:
+        assert False, "Not implemented for given platform."
+
+
+def remove_all_build_rpaths(filename):
+    if platform.system() == "Darwin":
+        build_paths = get_all_rpaths(filename)
+        for build_path in build_paths:
+            try:
+                cmd_params = ["install_name_tool", "-delete_rpath", str(build_path), str(filename)]
+                call_subprocess(cmd_params)
+            except Exception as ex:
+                logger.error(f"Failed to remove rpath {build_path} from {filename}: {ex}")
+                pass
+
+        assert len(get_all_rpaths(filename)) == 0
+
+
+def remove_rpath(filename):
+    if platform.system() == "Darwin":
+        remove_all_build_rpaths(filename)
+    elif platform.system() == "Linux":
+        cmd_params = [
+            "patchelf",
+            "--remove-rpath",
+            str(filename),
+        ]
+        call_subprocess(cmd_params)
+
+
+def set_rpath_origin(filename):
+    if platform.system() == "Darwin":
+        cmd_params = ["install_name_tool", "-add_rpath", get_origin_keyword(), str(filename)]
+        call_subprocess(cmd_params)
+    elif platform.system() == "Linux":
+        cmd_params = [
+            "patchelf",
+            "--force-rpath",
+            "--set-rpath",
+            f"\\{get_origin_keyword()}",
+            str(filename),
+        ]
+        call_subprocess(cmd_params)
+
+
+def prep_build_setup(wow_stage: Path):
+    """
+    Prepare the source folders
+    """
+    logger.info(f"----------------- begin prepping {wow_stage}---------------------")
+
+    this_repo = Path(this_dir)
+    package_lxware_folder = this_repo / "wowool" / "package" / "lxware"
+    package_lib_folder = this_repo / "wowool" / "package" / "lib"
+
+    logger.debug(f"{this_repo}")
+
+    os.makedirs(package_lxware_folder, exist_ok=True)
+
+    stage_bin_folder = wow_stage / "bin"
+    stage_lib_folder = wow_stage / "lib"
+
+    icu_lib_folder = stage_lib_folder
+
+    tir_config_fn = wow_stage / "config.json"
+    if tir_config_fn.exists():
+        with open(tir_config_fn) as fh:
+            tir_config = json.load(fh)
+            TIR_VERSION = tir_config["version"]
+
+        sdk_version_fn = this_dir / "sdk_version.txt"
+        with open(sdk_version_fn) as fh:
+            current_sdk_version = fh.read().strip()
+
+        if current_sdk_version != TIR_VERSION:
+            raise ValueError(
+                f"""!!! The native python SDK requires version'{current_sdk_version}' of the cpp SDK, but found the version '{TIR_VERSION}' in {stage_lib_folder}\nChange {sdk_version_fn.stem}"""
+            )
+    else:
+        assert fusion_root
+        tir_version = this_dir / "sdk_version.txt"
+        if tir_version.exists():
+            with open(tir_version, "r") as fh:
+                TIR_VERSION = fh.read().strip()
+        else:
+            TIR_VERSION = os.environ["TIR_VERSION"]
+
+    # change the rpath for the end package to used $ORIGIN
+    pattern = f"*{NATIVE_SO_EXT}"
+    native_linux_pattern = f"*{NATIVE_SO_EXT}.{TIR_VERSION}"
+
+    platform_name = platform.system()
+    if "Windows" == platform_name:
+        icu_files = ["icudt.lib", "icuuc.lib"]
+    elif "Darwin" == platform_name:
+        icu_files = ["libicudata.dylib", "libicuuc.dylib"]
+    else:
+        icu_files = ["libicudata.so", "libicuuc.so"]
+
+    logger.info(f"{TIR_VERSION=} {package_lib_folder=} {native_linux_pattern=}")
+
+    package_lib_folder.mkdir(parents=True, exist_ok=True)
+    logger.info(f"copying native libs {stage_lib_folder} --> {package_lib_folder=} {package_lib_folder.exists()=}")
+    try:
+        for fn in stage_lib_folder.glob(native_linux_pattern):
+            target_fn = package_lib_folder / fn.name
+            logger.info(f"copy {fn} --> {target_fn}")
+
+            if fn.is_symlink():
+                logger.info(f"{fn} is symlink, skipping")
+                continue
+            shutil.copy2(fn, target_fn)
+            logger.info(f"[ok] copy {fn} --> {target_fn}")
+            # remove_rpath(target_fn)
+            # set_rpath_origin(target_fn)
+    except Exception as ex:
+        logger.error(f"Failed to copy native lib {ex}")
+        raise ex
+
+    logger.info(f"copying {stage_lib_folder=} to {package_lib_folder=} {package_lib_folder.exists()=}")
+    for fn in stage_lib_folder.glob(pattern):
+        target_fn = package_lib_folder / fn.name
+        if target_fn.name.startswith("_"):
+            continue
+        if fn.is_symlink():
+            # do not copy symlinks.
+            # shutil.copy2(fn, package_lib_folder / fn.name , follow_symlinks=False )
+            pass
+        else:
+            if target_fn.exists():
+                target_fn.unlink()
+            target_fn.parent.mkdir(parents=True, exist_ok=True)
+            logger.info(f"!!!!! COPY3  {fn} --> {target_fn}")
+            shutil.copy2(fn, target_fn)
+
+    # copy icu
+    logger.info("----------------- before ---------------------")
+    for fn in package_lib_folder.glob("**/*"):
+        logger.info(f"package: {fn}")
+
+    for fn in icu_files:
+        target_fn = package_lib_folder / fn
+        shutil.copy2(icu_lib_folder / fn, target_fn)
+        # remove_rpath(target_fn)
+        # set_rpath_origin(target_fn)
+
+    if "Windows" == platform_name:
+        # for windows we also need to copy the dll
+        bin_files = [[fn] for fn in stage_bin_folder.glob("*.dll")]
+        bin_files.append([stage_bin_folder / "wow.exe", "wow++.exe"])
+        bin_files.append([stage_bin_folder / "woc.exe", "woc++.exe"])
+        bin_files.append([stage_bin_folder / "afst.exe", "afst++.exe"])
+    else:
+        bin_files = []
+        bin_files.append([stage_bin_folder / "wow", "wow++"])
+        bin_files.append([stage_bin_folder / "woc", "woc++"])
+        bin_files.append([stage_bin_folder / "afst", "afst++"])
+
+    for fn in bin_files:
+        if len(fn) == 1:
+            target_fn = package_lib_folder / fn[0].name
+        else:
+            target_fn = package_lib_folder / fn[1]
+
+        shutil.copy2(fn[0], target_fn)
+        remove_rpath(target_fn)
+        logger.info(f"set_rpath_origin {target_fn}")
+        set_rpath_origin(target_fn)
+    logger.info("----------------- end prepping ---------------------")
+    for fn in package_lib_folder.glob("**/*"):
+        if "__pycache_" not in str(fn):
+            logger.info(f"package: {fn}")
+
+
+def post_build_setup(stage: Path):
+    """
+    Prepare the source folders
+    """
+
+    print("post_build ... ")
+    files = [fn for fn in stage.glob(f"lib/*{NATIVE_SO_EXT}")]
+    for fn in files:
+        print(f"post_build : remove rpaths {fn}")
+        remove_rpath(fn)
+        set_rpath_origin(fn)

wowool_sdk_cpp-3.4.5/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.black]
+line-length = 140
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "."
+]
+testpaths= [ "tests/wowool/native/core" ]
+
+addopts = [
+    "--import-mode=importlib"
+]
+
+[build-system]
+requires = ["setuptools >= 65.5.0" , "requests"]
+build-backend = "setuptools.build_meta"

wowool_sdk_cpp-3.4.5/sdk_version.txt

@@ -0,0 +1 @@
+3.1.2

wowool_sdk_cpp-3.4.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+