wowool-sdk-cpp 3.5.6__tar.gz → 3.6.0__tar.gz

{wowool_sdk_cpp-3.5.6 → wowool_sdk_cpp-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wowool-sdk-cpp
-Version: 3.5.6
+Version: 3.6.0
 Summary: Wowool NLP Toolkit C++ SDK Python Bindings
 Author: Wowool
 Requires-Python: >=3.11

wowool_sdk_cpp-3.6.0/sdk_version.txt

@@ -0,0 +1 @@
+3.2.0

wowool_sdk_cpp-3.6.0/version.txt

@@ -0,0 +1 @@
+3.6.0

{wowool_sdk_cpp-3.5.6 → wowool_sdk_cpp-3.6.0}/wowool/native/core/wowool_sdk.cpp

@@ -3,16 +3,6 @@
 // Otherwise MSVC can not compile the stuff
 /////////////////////////////////////////////////////////////////
 #define WITH_THREAD
-#include <Python.h>
-#include <iostream>
-#include <mutex>
-#include <pybind11/functional.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <string>
-#include <thread>
-#include <variant>
-#include <vector>
 #include "wowool/analyzer/analyzer.hpp"
 #include "wowool/analyzer/options.hpp"
 #include "wowool/common/exception.hpp"
@@ -23,11 +13,21 @@
 #include "wowool/engine/engine.hpp"
 #include "wowool/filter/filter.hpp"
 #include "wowool/language_identifier/language_identifier.hpp"
+#include <Python.h>
+#include <iostream>
+#include <mutex>
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <string>
+#include <thread>
+#include <variant>
+#include <vector>
 #if !defined(WIN32)
-	#include <signal.h>
+#include <signal.h>
 #else
-	#include <thread>
-	#include <windows.h>
+#include <thread>
+#include <windows.h>
 #endif
 namespace py = pybind11;
 
@@ -38,392 +38,372 @@ namespace py = pybind11;
 std::mutex global_python_mutex;
 #define PYTHON_LOCK std::lock_guard<std::mutex> guard(global_python_mutex);
 
-bool get_environment_bool(std::string const &env_id, bool default_value)
-{
-	char const *value_ptr = std::getenv(env_id.c_str());
-	if (value_ptr)
-	{
-		std::string value(value_ptr);
-		return value == "true" or value == "True";
-	}
-	return default_value;
+bool get_environment_bool(std::string const &env_id, bool default_value) {
+  char const *value_ptr = std::getenv(env_id.c_str());
+  if (value_ptr) {
+    std::string value(value_ptr);
+    return value == "true" or value == "True";
+  }
+  return default_value;
 }
 
 bool lock_gil = get_environment_bool("WOWOOL_LOCK_GIL", false);
 
 namespace detail {
-	struct DoNotExecFirstTime
-	{
-		mutable bool initial = true;
+struct DoNotExecFirstTime {
+  mutable bool initial = true;
 
-		template<typename Functor>
-		void operator()(Functor functor) const
-		{
-			if (!initial)
-			{
-				functor();
-			}
-			else
-				initial = false;
-		}
+  template <typename Functor> void operator()(Functor functor) const {
+    if (!initial) {
+      functor();
+    } else
+      initial = false;
+  }
 
-		void reset() { initial = true; }
-	};
+  void reset() { initial = true; }
+};
 
 } // namespace detail
 
-std::ostream &print_string_map(std::ostream &out, wowool::common::Options const &options)
-{
-	for (auto const &option : options)
-	{
-		out << option.first << ":" << option.second << ",";
-	}
-	return out;
+std::ostream &print_string_map(std::ostream &out,
+                               wowool::common::Options const &options) {
+  for (auto const &option : options) {
+    out << option.first << ":" << option.second << ",";
+  }
+  return out;
 }
 
 namespace tir {
 namespace pywowool {
 
-	class exception_t : public std::exception
-	{
-	private:
-		std::string message;
-		std::string extraData;
-
-	public:
-		exception_t(std::string message_, std::string extraData_)
-			: message(message_), extraData(extraData_) {}
-		// TODO: declare this nothrow
-		~exception_t() throw() {}
-		const char *what() const throw() { return message.c_str(); }
-		std::string getMessage() { return message; }
-		std::string getExtraData() { return extraData; }
-	};
-
-	class exception_json_t : public std::exception
-	{
-	private:
-		std::string json_data;
-
-	public:
-		exception_json_t(std::string json_data_)
-			: json_data(json_data_) {}
-		// TODO: declare this nothrow
-		~exception_json_t() throw() {}
-		const char *what() const throw() { return json_data.c_str(); }
-	};
-
-	void translate(exception_json_t const &e)
-	{
-		PyErr_SetString(PyExc_RuntimeError, e.what());
-	}
-	void translate(exception_t const &e)
-	{
-		PyErr_SetString(PyExc_RuntimeError, e.what());
-	}
-
-	wowool::common::Options convert_py_2_api_options(py::dict const &kwargs)
-	{
-		wowool::common::Options options;
-		for (auto const &item : kwargs)
-		{
-			options.emplace(py::str(item.first), py::str(item.second));
-		}
-		return options;
-	}
-
-	std::string convert_filterset(wowool::filter::Filter const &filterset)
-	{
-		return filterset.info();
-	}
-
-	py::dict convert_options_2_py(wowool::common::Options const &options)
-	{
-		py::dict kwargs;
-		for (auto const &item : options)
-		{
-			kwargs[py::str(item.first)] = py::str(item.second);
-		}
-		return kwargs;
-	}
-
-	// self.options["pytryoshka"] = "true"
-
-	static wowool::common::Options global_shared_engine_options = {
-		{std::string("language"), std::string("auto")},
-		// { std::string("verbose")  , std::string("trace") },
-		{std::string("pytryoshka"), std::string("true")}};
-
-	static std::shared_ptr<wowool::engine::Engine>
-		global_shared_engine; //( global_shared_engine_options );
-
-	wowool::engine::Engine &get_default_engine(wowool::common::Options &options)
-	{
-		PYTHON_LOCK
-
-		if (!global_shared_engine)
-		{
-			wowool::engine::Engine *global_wowool_engine = new wowool::engine::Engine(options);
-			// std::cout << " !!!!!!!!!!!!!! Creating Global Engine" << global_wowool_engine << std::endl;
-			global_shared_engine.reset(global_wowool_engine);
-		}
-		return *global_shared_engine;
-	}
-
-	class engine_t : public wowool::engine::Engine
-	{
-	public:
-		// typedef wowool::EngineInterface type;
-
-		typedef wowool::engine::Engine type;
-
-		// using wowool::engine::Engine::Engine;
-
-		// engine_t(wowool::engine::Engine const &&base)
-		// 	: wowool::engine::Engine(std::move(base))
-		// {
-		// 	std::cout << "PLUGIN wowool::engine::Engine(wowool::engine::Engine const &&base)" << this << std::endl;
-		// }
-
-		// engine_t(wowool::engine::Engine const &&base, py::dict const &kwarg)
-		// 	: wowool::engine::Engine(tir::pywowool::convert_py_2_api_options(kwarg))
-		// {
-		// 	std::cout << "PLUGIN wowool::engine::Engine(wowool::engine::Engine const &&base, py::dict const &kwarg)" << this << std::endl;
-		// }
-
-		// we need this one to be able to create multi_process objects.
-		engine_t(py::dict const &kwarg)
-			: wowool::engine::Engine(tir::pywowool::convert_py_2_api_options(kwarg))
-		{
-		}
-	};
-
-	class lid_t : public wowool::language_identifier::LanguageIdentifier
-	{
-	public:
-		typedef wowool::language_identifier::LanguageIdentifier type;
-
-		using wowool::language_identifier::LanguageIdentifier::LanguageIdentifier;
-
-		lid_t(wowool::language_identifier::LanguageIdentifier const &&base)
-			: wowool::language_identifier::LanguageIdentifier(std::move(base)) {}
-
-		lid_t(wowool::analyzer::Engine const &engine, py::dict const &kwarg)
-			: wowool::language_identifier::LanguageIdentifier(engine, tir::pywowool::convert_py_2_api_options(kwarg)) {}
-
-		lid_t(py::dict const &kwarg)
-			: wowool::language_identifier::LanguageIdentifier(tir::pywowool::get_default_engine(global_shared_engine_options), tir::pywowool::convert_py_2_api_options(kwarg)) {}
-	};
-
-	class domain_t : public wowool::domain::Domain
-	{
-	public:
-		typedef wowool::domain::Domain type;
-
-		using wowool::domain::Domain::Domain;
-
-		domain_t(wowool::domain::Domain const &&base)
-			: wowool::domain::Domain(std::move(base)) {}
-
-		domain_t(wowool::analyzer::Engine const &engine, std::string const domain_descriptor, py::dict const &kwarg)
-			: wowool::domain::Domain(engine, domain_descriptor, tir::pywowool::convert_py_2_api_options(kwarg)) {}
-
-		// we need this one to be able to create multi_process objects.
-		domain_t(py::dict const &kwarg)
-			: wowool::domain::Domain(
-				tir::pywowool::get_default_engine(global_shared_engine_options),
-				kwarg["name"].cast<std::string>(),
-				tir::pywowool::convert_py_2_api_options(kwarg)) {}
-
-		// wowool::analyzer::Results process(wowool::analyzer::Results const document)
-		// {
-		// 	char *p = 0;
-		// 	*p = 0;
-		// 	std::cout << "PLUGIN domain_t::process" << std::endl;
-		// 	// py::gil_scoped_release release; // Release the GIL
-		// 	return (*static_cast<wowool::domain::Domain const *>(this))(document);
-		// };
-	};
-
-	wowool::filter::FilterCollection string2filterset(std::string const &filter_str)
-	{
-		auto filter_vector = wowool::common::split(filter_str, ',');
-		return wowool::filter::FilterCollection(filter_vector.begin(), filter_vector.end());
-	}
-
-	class filter_t : public wowool::filter::Filter
-	{
-	public:
-		typedef wowool::filter::Filter type;
-
-		using wowool::filter::Filter::Filter;
-
-		filter_t(wowool::filter::Filter const &&base)
-			: wowool::filter::Filter(std::move(base)) {}
-
-		filter_t(wowool::filter::FilterCollection const &filterset)
-			: wowool::filter::Filter(filterset), _filterset(filterset) {}
-
-		filter_t(std::string const filterset)
-			: wowool::filter::Filter(filterset), _filterset(string2filterset(filterset)) {}
+class exception_t : public std::exception {
+private:
+  std::string message;
+  std::string extraData;
+
+public:
+  exception_t(std::string message_, std::string extraData_)
+      : message(message_), extraData(extraData_) {}
+  // TODO: declare this nothrow
+  ~exception_t() throw() {}
+  const char *what() const throw() { return message.c_str(); }
+  std::string getMessage() { return message; }
+  std::string getExtraData() { return extraData; }
+};
+
+class exception_json_t : public std::exception {
+private:
+  std::string json_data;
+
+public:
+  exception_json_t(std::string json_data_) : json_data(json_data_) {}
+  // TODO: declare this nothrow
+  ~exception_json_t() throw() {}
+  const char *what() const throw() { return json_data.c_str(); }
+};
+
+void translate(exception_json_t const &e) {
+  PyErr_SetString(PyExc_RuntimeError, e.what());
+}
+void translate(exception_t const &e) {
+  PyErr_SetString(PyExc_RuntimeError, e.what());
+}
 
-		wowool::filter::FilterCollection const _filterset;
-	};
+wowool::common::Options convert_py_2_api_options(py::dict const &kwargs) {
+  wowool::common::Options options;
+  for (auto const &item : kwargs) {
+    options.emplace(py::str(item.first), py::str(item.second));
+  }
+  return options;
+}
 
-	class results_t : public wowool::analyzer::Results
-	{
-	public:
-		typedef wowool::analyzer::Results type;
+std::string convert_filterset(wowool::filter::Filter const &filterset) {
+  return filterset.info();
+}
 
-		using wowool::analyzer::Results::Results;
+py::dict convert_options_2_py(wowool::common::Options const &options) {
+  py::dict kwargs;
+  for (auto const &item : options) {
+    kwargs[py::str(item.first)] = py::str(item.second);
+  }
+  return kwargs;
+}
 
-		results_t(wowool::analyzer::Results const &&base)
-			: wowool::analyzer::Results(std::move(base)) {}
-	};
+// self.options["pytryoshka"] = "true"
 
-	class analyzer_t : public wowool::analyzer::Analyzer
-	{
-	public:
-		typedef wowool::analyzer::Analyzer type;
-		py::dict _kwargs;
+static wowool::common::Options global_shared_engine_options = {
+    {std::string("language"), std::string("auto")},
+    // { std::string("verbose")  , std::string("trace") },
+    {std::string("pytryoshka"), std::string("true")}};
 
-		using wowool::analyzer::Analyzer::Analyzer;
-		using wowool::analyzer::Analyzer::operator();
+static std::shared_ptr<wowool::engine::Engine>
+    global_shared_engine; //( global_shared_engine_options );
 
-		analyzer_t(wowool::analyzer::Analyzer const &&base)
-			: wowool::analyzer::Analyzer(std::move(base)) {}
+wowool::engine::Engine &get_default_engine(wowool::common::Options &options) {
+  PYTHON_LOCK
 
-		analyzer_t(wowool::analyzer::Engine const &engine, py::dict const &kwarg)
-			: wowool::analyzer::Analyzer(engine, tir::pywowool::convert_py_2_api_options(kwarg)), _kwargs(kwarg) {}
+  if (!global_shared_engine) {
+    wowool::engine::Engine *global_wowool_engine =
+        new wowool::engine::Engine(options);
+    // std::cout << " !!!!!!!!!!!!!! Creating Global Engine" <<
+    // global_wowool_engine << std::endl;
+    global_shared_engine.reset(global_wowool_engine);
+  }
+  return *global_shared_engine;
+}
 
-		std::string process_return_string(std::string const &document, wowool::common::Options const &json_options)
-		{
-			std::string ret_val;
-			// std::cout << "options:" ; print_string_map(std::cout , json_options);
-			// std::cout << std::endl;
-			auto results = (*this)(document, json_options);
-			return results.to_json();
-		}
-	};
-
-	std::string pipeline_expand(std::string const &pipeline, std::string const &paths_str, bool file_access, bool allow_dev_versions, std::string const &pipeline_language)
-	{
-		try
-		{
-			std::vector<std::string> paths = wowool::common::split(paths_str, ',');
-			return wowool::engine::expand_pipeline(pipeline, paths, file_access, allow_dev_versions, pipeline_language);
-		} catch (wowool::common::JsonException const &ex)
-		{
-			throw exception_json_t(ex.what());
-		}
-	}
+class engine_t : public wowool::engine::Engine {
+public:
+  // typedef wowool::EngineInterface type;
+
+  typedef wowool::engine::Engine type;
+
+  // using wowool::engine::Engine::Engine;
+
+  // engine_t(wowool::engine::Engine const &&base)
+  // 	: wowool::engine::Engine(std::move(base))
+  // {
+  // 	std::cout << "PLUGIN wowool::engine::Engine(wowool::engine::Engine const
+  // &&base)" << this << std::endl;
+  // }
+
+  // engine_t(wowool::engine::Engine const &&base, py::dict const &kwarg)
+  // 	: wowool::engine::Engine(tir::pywowool::convert_py_2_api_options(kwarg))
+  // {
+  // 	std::cout << "PLUGIN wowool::engine::Engine(wowool::engine::Engine const
+  // &&base, py::dict const &kwarg)" << this << std::endl;
+  // }
+
+  // we need this one to be able to create multi_process objects.
+  engine_t(py::dict const &kwarg)
+      : wowool::engine::Engine(tir::pywowool::convert_py_2_api_options(kwarg)) {
+  }
+};
+
+class lid_t : public wowool::language_identifier::LanguageIdentifier {
+public:
+  typedef wowool::language_identifier::LanguageIdentifier type;
+
+  using wowool::language_identifier::LanguageIdentifier::LanguageIdentifier;
+
+  lid_t(wowool::language_identifier::LanguageIdentifier const &&base)
+      : wowool::language_identifier::LanguageIdentifier(std::move(base)) {}
+
+  lid_t(wowool::analyzer::Engine const &engine, py::dict const &kwarg)
+      : wowool::language_identifier::LanguageIdentifier(
+            engine, tir::pywowool::convert_py_2_api_options(kwarg)) {}
+
+  lid_t(py::dict const &kwarg)
+      : wowool::language_identifier::LanguageIdentifier(
+            tir::pywowool::get_default_engine(global_shared_engine_options),
+            tir::pywowool::convert_py_2_api_options(kwarg)) {}
+};
+
+class domain_t : public wowool::domain::Domain {
+public:
+  typedef wowool::domain::Domain type;
+
+  using wowool::domain::Domain::Domain;
+
+  domain_t(wowool::domain::Domain const &&base)
+      : wowool::domain::Domain(std::move(base)) {}
+
+  domain_t(wowool::analyzer::Engine const &engine,
+           std::string const domain_descriptor, py::dict const &kwarg)
+      : wowool::domain::Domain(engine, domain_descriptor,
+                               tir::pywowool::convert_py_2_api_options(kwarg)) {
+  }
+
+  // we need this one to be able to create multi_process objects.
+  domain_t(py::dict const &kwarg)
+      : wowool::domain::Domain(
+            tir::pywowool::get_default_engine(global_shared_engine_options),
+            kwarg["name"].cast<std::string>(),
+            tir::pywowool::convert_py_2_api_options(kwarg)) {}
+
+  // wowool::analyzer::Results process(wowool::analyzer::Results const document)
+  // {
+  // 	char *p = 0;
+  // 	*p = 0;
+  // 	std::cout << "PLUGIN domain_t::process" << std::endl;
+  // 	// py::gil_scoped_release release; // Release the GIL
+  // 	return (*static_cast<wowool::domain::Domain const *>(this))(document);
+  // };
+};
+
+wowool::filter::FilterCollection
+string2filterset(std::string const &filter_str) {
+  auto filter_vector = wowool::common::split(filter_str, ',');
+  return wowool::filter::FilterCollection(filter_vector.begin(),
+                                          filter_vector.end());
+}
 
-	bool is_valid_version_format(std::string const &version)
-	{
-		return wowool::common::is_valid_version_format(version);
-	}
+class filter_t : public wowool::filter::Filter {
+public:
+  typedef wowool::filter::Filter type;
+
+  using wowool::filter::Filter::Filter;
+
+  filter_t(wowool::filter::Filter const &&base)
+      : wowool::filter::Filter(std::move(base)) {}
+
+  filter_t(wowool::filter::FilterCollection const &filterset)
+      : wowool::filter::Filter(filterset), _filterset(filterset) {}
+
+  filter_t(std::string const filterset)
+      : wowool::filter::Filter(filterset),
+        _filterset(string2filterset(filterset)) {}
+
+  wowool::filter::FilterCollection const _filterset;
+};
+
+class results_t : public wowool::analyzer::Results {
+public:
+  typedef wowool::analyzer::Results type;
+
+  using wowool::analyzer::Results::Results;
+
+  results_t(wowool::analyzer::Results const &&base)
+      : wowool::analyzer::Results(std::move(base)) {}
+};
+
+class analyzer_t : public wowool::analyzer::Analyzer {
+public:
+  typedef wowool::analyzer::Analyzer type;
+  py::dict _kwargs;
+
+  using wowool::analyzer::Analyzer::Analyzer;
+  using wowool::analyzer::Analyzer::operator();
+
+  analyzer_t(wowool::analyzer::Analyzer const &&base)
+      : wowool::analyzer::Analyzer(std::move(base)) {}
+
+  analyzer_t(wowool::analyzer::Engine const &engine, py::dict const &kwarg)
+      : wowool::analyzer::Analyzer(
+            engine, tir::pywowool::convert_py_2_api_options(kwarg)),
+        _kwargs(kwarg) {}
+
+  std::string
+  process_return_string(std::string const &document,
+                        wowool::common::Options const &json_options) {
+    std::string ret_val;
+    // std::cout << "options:" ; print_string_map(std::cout , json_options);
+    // std::cout << std::endl;
+    auto results = (*this)(document, json_options);
+    return results.to_json();
+  }
+};
+
+std::string pipeline_expand(std::string const &pipeline,
+                            std::string const &paths_str, bool file_access,
+                            bool allow_dev_versions,
+                            std::string const &pipeline_language) {
+  try {
+    std::vector<std::string> paths = wowool::common::split(paths_str, ',');
+    return wowool::engine::expand_pipeline(
+        pipeline, paths, file_access, allow_dev_versions, pipeline_language);
+  } catch (wowool::common::JsonException const &ex) {
+    throw exception_json_t(ex.what());
+  }
+}
 
-	std::string get_domain_info(std::string const domains_str)
-	{
-		std::vector<std::string> all_groups;
-		std::vector<std::string> domains = wowool::common::split(domains_str, ',');
-		std::stringstream json;
-		try
-		{
-			for (auto const &domain_descriptor : domains)
-			{
-				std::vector<std::string> groups;
-				std::string domain = domain_descriptor;
-				wowool::domain::get_domain_concepts(domain, groups);
-				std::copy(groups.begin(), groups.end(), std::back_inserter(all_groups));
-			}
-		} catch (std::exception const &ex)
-		{
-			throw exception_t(ex.what(), "");
-		}
+std::string pipeline_parse(std::string const &pipeline) {
+  try {
+    return wowool::engine::parse_pipeline(pipeline);
+  } catch (wowool::common::JsonException const &ex) {
+    throw exception_json_t(ex.what());
+  }
+}
 
-		if (!all_groups.empty())
-		{
-			json << "[";
-			detail::DoNotExecFirstTime dneft;
-			for (auto const &concept : all_groups)
-			{
-				if (concept.empty())
-					continue;
+bool is_valid_version_format(std::string const &version) {
+  return wowool::common::is_valid_version_format(version);
+}
 
-				dneft([&json]() { json << ","; });
-				json << "\"" << concept << "\"";
-			}
-			json << "]";
-			return json.str();
-		}
-		else
-		{
-			json << "[]";
-		}
-		return json.str();
-	}
+std::string get_domain_info(std::string const domains_str) {
+  std::vector<std::string> all_groups;
+  std::vector<std::string> domains = wowool::common::split(domains_str, ',');
+  std::stringstream json;
+  try {
+    for (auto const &domain_descriptor : domains) {
+      std::vector<std::string> groups;
+      std::string domain = domain_descriptor;
+      wowool::domain::get_domain_concepts(domain, groups);
+      std::copy(groups.begin(), groups.end(), std::back_inserter(all_groups));
+    }
+  } catch (std::exception const &ex) {
+    throw exception_t(ex.what(), "");
+  }
+
+  if (!all_groups.empty()) {
+    json << "[";
+    detail::DoNotExecFirstTime dneft;
+    for (auto const &concept : all_groups) {
+      if (concept.empty())
+        continue;
+
+      dneft([&json]() { json << ","; });
+      json << "\"" << concept << "\"";
+    }
+    json << "]";
+    return json.str();
+  } else {
+    json << "[]";
+  }
+  return json.str();
+}
 
-	void print_log_message(unsigned short id, char const *msg)
-	{
-		std::cout << msg << std::endl;
-	}
+void print_log_message(unsigned short id, char const *msg) {
+  std::cout << msg << std::endl;
+}
 
-	std::string compile_domain(std::string const domain_descriptor, py::dict const &kwargs)
-	{
-		try
-		{
-			auto options = convert_py_2_api_options(kwargs);
-			return wowool::domain::compile_domain(options);
-		} catch (wowool::common::Exception &ex)
-		{
-			throw exception_t(ex.what(), "");
-		} catch (std::exception const &e)
-		{
-			throw exception_t(e.what(), "");
-		}
-	}
+std::string compile_domain(std::string const domain_descriptor,
+                           py::dict const &kwargs) {
+  try {
+    auto options = convert_py_2_api_options(kwargs);
+    return wowool::domain::compile_domain(options);
+  } catch (wowool::common::Exception &ex) {
+    throw exception_t(ex.what(), "");
+  } catch (std::exception const &e) {
+    throw exception_t(e.what(), "");
+  }
+}
 
-	struct options_t
-	{
-		static const std::string language;
-	};
+struct options_t {
+  static const std::string language;
+};
 
-	const std::string options_t::language = wowool::analyzer::option::language;
+const std::string options_t::language = wowool::analyzer::option::language;
 
-	auto __exit__callback = []() {
-		PYTHON_LOCK
-		global_shared_engine.reset();
-	};
+auto __exit__callback = []() {
+  PYTHON_LOCK
+  global_shared_engine.reset();
+};
 
-	struct PyLog
-	{
-		std::function<void(unsigned short, const char *)> logit;
+struct PyLog {
+  std::function<void(unsigned short, const char *)> logit;
 
-		PyLog(std::function<void(unsigned short, const char *)> logit_)
-			: logit(logit_) {}
-	};
+  PyLog(std::function<void(unsigned short, const char *)> logit_)
+      : logit(logit_) {}
+};
 
-	std::function<void(int, std::string)> pylogit;
+std::function<void(int, std::string)> pylogit;
 
-	void global_logger_fn(unsigned short id, const char *msg)
-	{
-		if (pylogit)
-		{
-			pylogit(id, std::string(msg));
-		}
-	}
+void global_logger_fn(unsigned short id, const char *msg) {
+  if (pylogit) {
+    pylogit(id, std::string(msg));
+  }
+}
 
-	void add_logger(unsigned short id, std::string level, const std::function<void(int, std::string)> logit)
-	{
-		pylogit = logit;
-		wowool::logging::add_logger(id, level, global_logger_fn);
-	}
+void add_logger(unsigned short id, std::string level,
+                const std::function<void(int, std::string)> logit) {
+  pylogit = logit;
+  wowool::logging::add_logger(id, level, global_logger_fn);
+}
 
-	void unset_logger() { pylogit = nullptr; }
+void unset_logger() { pylogit = nullptr; }
 
-}
-} // namespace tir::pywowool
+} // namespace pywowool
+} // namespace tir
 
 // clang-format off
 
@@ -444,6 +424,7 @@ PYBIND11_MODULE(_wowool_sdk, m)
     m.add_object("_cleanup", py::capsule(tir::pywowool::__exit__callback));
     m.def("get_domain_info", tir::pywowool::get_domain_info);
     m.def("pipeline_expand", tir::pywowool::pipeline_expand);
+    m.def("pipeline_parse", tir::pywowool::pipeline_parse);
     m.def("is_valid_version_format", tir::pywowool::is_valid_version_format);
     m.def("compile_domain", tir::pywowool::compile_domain);
     m.def("add_logger", tir::pywowool::add_logger);

{wowool_sdk_cpp-3.5.6 → wowool_sdk_cpp-3.6.0}/wowool/package/lib/wowool_sdk.py

@@ -29,6 +29,7 @@ from _wowool_sdk import (
     results,
     TirJsonException,
     pipeline_expand,
+    pipeline_parse,
     compile_domain,
     analyzer,
     engine,

{wowool_sdk_cpp-3.5.6 → wowool_sdk_cpp-3.6.0}/wowool_sdk_cpp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wowool-sdk-cpp
-Version: 3.5.6
+Version: 3.6.0
 Summary: Wowool NLP Toolkit C++ SDK Python Bindings
 Author: Wowool
 Requires-Python: >=3.11

wowool_sdk_cpp-3.5.6/sdk_version.txt

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

wowool_sdk_cpp-3.5.6/version.txt

@@ -1 +0,0 @@
-3.5.6