netgen-mesher 6.2.2506.post35.dev0__cp314-cp314-win_amd64.whl

netgen/include/core/python_ngcore.hpp

@@ -0,0 +1,457 @@
+#ifndef NETGEN_CORE_PYTHON_NGCORE_HPP
+#define NETGEN_CORE_PYTHON_NGCORE_HPP
+
+#include "ngcore_api.hpp" // for operator new
+#include <pybind11/pybind11.h>
+#include <pybind11/operators.h>
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+#include <pybind11/stl/filesystem.h>
+
+#include "array.hpp"
+#include "table.hpp"
+#include "archive.hpp"
+#include "flags.hpp"
+#include "ngcore_api.hpp"
+#include "ng_mpi.hpp"
+
+namespace py = pybind11;
+
+namespace ngcore
+{
+#ifdef PARALLEL
+  NGCORE_API extern bool (*NG_MPI_CommFromMPI4Py)(py::handle, NG_MPI_Comm &);
+  NGCORE_API extern py::handle (*NG_MPI_CommToMPI4Py)(NG_MPI_Comm);
+#endif // PARALLEL
+
+  namespace detail
+  {
+    template<typename T>
+    struct HasPyFormat
+    {
+    private:
+      template<typename T2>
+      static auto check(T2*) -> std::enable_if_t<std::is_same_v<decltype(std::declval<py::format_descriptor<T2>>().format()), std::string>, std::true_type>;
+      static auto check(...) -> std::false_type;
+    public:
+      static constexpr bool value = decltype(check((T*) nullptr))::value;
+    };
+  } // namespace detail
+
+#ifdef PARALLEL
+  struct mpi4py_comm {
+    mpi4py_comm() = default;
+    mpi4py_comm(NG_MPI_Comm value) : value(value) {}
+    operator NG_MPI_Comm () { return value; }
+
+    NG_MPI_Comm value;
+  };
+#endif  // PARALLEL
+} // namespace ngcore
+
+
+////////////////////////////////////////////////////////////////////////////////
+// automatic conversion of python list to Array<>
+namespace pybind11 {
+namespace detail {
+
+#ifdef PARALLEL
+template <> struct type_caster<ngcore::mpi4py_comm> {
+  public:
+  PYBIND11_TYPE_CASTER(ngcore::mpi4py_comm, _("mpi4py_comm"));
+
+    // Python -> C++
+    bool load(handle src, bool) {
+      return ngcore::NG_MPI_CommFromMPI4Py(src, value.value);
+    }
+
+    // C++ -> Python
+    static handle cast(ngcore::mpi4py_comm src,
+                       return_value_policy /* policy */,
+                       handle /* parent */)
+    {
+      // Create an mpi4py handle
+      return ngcore::NG_MPI_CommToMPI4Py(src.value);
+    }
+};
+#endif //  PARALLEL
+
+template <typename Type, typename Value> struct ngcore_list_caster {
+    using value_conv = make_caster<Value>;
+
+    bool load(handle src, bool convert) {
+        if (!isinstance<sequence>(src) || isinstance<str>(src))
+            return false;
+        auto s = reinterpret_borrow<sequence>(src);
+        value.SetSize(s.size());
+        value.SetSize0();
+        for (auto it : s) {
+            value_conv conv;
+            if (!conv.load(it, convert))
+                return false;
+            value.Append(cast_op<Value &&>(std::move(conv)));
+        }
+        return true;
+    }
+
+public:
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent) {
+        if (!std::is_lvalue_reference<T>::value)
+            policy = return_value_policy_override<Value>::policy(policy);
+        list l(src.Size());
+        size_t index = 0;
+        for (auto &&value : src) {
+            auto value_ = reinterpret_steal<object>(value_conv::cast(forward_like<T>(value), policy, parent));
+            if (!value_)
+                return handle();
+            PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr()); // steals a reference
+        }
+        return l.release();
+    }
+
+    PYBIND11_TYPE_CASTER(Type, _("Array[") + value_conv::name + _("]"));
+};
+
+
+template <typename Type> struct type_caster<ngcore::Array<Type>, enable_if_t<!ngcore::detail::HasPyFormat<Type>::value>>
+ : ngcore_list_caster<ngcore::Array<Type>, Type> { };
+
+
+  /*
+  template <typename Type> struct type_caster<std::shared_ptr<ngcore::Table<Type>>>
+  {
+    template <typename T>
+    static handle cast(T &&src, return_value_policy policy, handle parent)
+    {
+      std::cout << "handle called with type src = " << typeid(src).name() << std::endl;
+
+      return handle(); // what so ever
+    }
+    
+    PYBIND11_TYPE_CASTER(Type, _("Table[") + make_caster<Type>::name + _("]"));
+  };
+  */
+  
+  
+
+} // namespace detail
+} // namespace pybind11
+////////////////////////////////////////////////////////////////////////////////
+
+namespace ngcore
+{
+  NGCORE_API extern bool ngcore_have_numpy;
+  NGCORE_API extern bool parallel_pickling;
+  
+  // Python class name type traits
+  template <typename T>
+  struct PyNameTraits {
+    static const std::string & GetName()
+    {
+      static const std::string name = typeid(T).name();
+      return name;
+    }
+  };
+
+  template <typename T>
+  std::string GetPyName(const char *prefix = 0) {
+    std::string s;
+    if(prefix) s = std::string(prefix);
+    s+= PyNameTraits<T>::GetName();
+    return s;
+  }
+
+  template<>
+  struct PyNameTraits<int> {
+    static std::string GetName() { return "I"; }
+  };
+
+  template<>
+  struct PyNameTraits<unsigned> {
+    static std::string GetName() { return "U"; }
+  };
+
+  template<>
+  struct PyNameTraits<float> {
+    static std::string GetName() { return "F"; }
+  };
+
+  template<>
+  struct PyNameTraits<double> {
+    static std::string GetName() { return "D"; }
+  };
+
+  template<>
+  struct PyNameTraits<size_t> {
+    static std::string GetName() { return "S"; }
+  };
+
+  template<typename T>
+  struct PyNameTraits<std::shared_ptr<T>> {
+    static std::string GetName()
+    { return std::string("sp_")+GetPyName<T>(); }
+  };
+
+  template<typename ARCHIVE>
+  class NGCORE_API_EXPORT PyArchive : public ARCHIVE
+  {
+  private:
+    pybind11::list lst;
+    size_t index = 0;
+    std::map<std::string, VersionInfo> version_needed;
+  protected:
+    using ARCHIVE::stream;
+    using ARCHIVE::version_map;
+  public:
+    PyArchive(const pybind11::object& alst = pybind11::none()) :
+      ARCHIVE(std::make_shared<std::stringstream>()),
+      lst(alst.is_none() ? pybind11::list() : pybind11::cast<pybind11::list>(alst))
+    {
+      ARCHIVE::shallow_to_python = true;
+      if(Input())
+        {
+          stream = std::make_shared<std::stringstream>
+            (pybind11::cast<pybind11::bytes>(lst[pybind11::len(lst)-1]));
+          *this & version_needed;
+          for(auto& libversion : version_needed)
+            if(libversion.second > GetLibraryVersion(libversion.first))
+              throw Exception("Error in unpickling data:\nLibrary " + libversion.first +
+                              " must be at least " + libversion.second.to_string());
+          stream = std::make_shared<std::stringstream>
+            (pybind11::cast<pybind11::bytes>(lst[pybind11::len(lst)-2]));
+          *this & version_map;
+          stream = std::make_shared<std::stringstream>
+            (pybind11::cast<pybind11::bytes>(lst[pybind11::len(lst)-3]));
+        }
+    }
+
+    void NeedsVersion(const std::string& library, const std::string& version) override
+    {
+      if(Output())
+        {
+          version_needed[library] = version_needed[library] > version ? version_needed[library] : version;
+        }
+    }
+
+    using ARCHIVE::Output;
+    using ARCHIVE::Input;
+    using ARCHIVE::FlushBuffer;
+    using ARCHIVE::operator&;
+    using ARCHIVE::operator<<;
+    using ARCHIVE::GetVersion;
+    void ShallowOutPython(const pybind11::object& val) override { lst.append(val); }
+    void ShallowInPython(pybind11::object& val) override { val = lst[index++]; }
+
+    pybind11::list WriteOut()
+    {
+      auto version_runtime = GetLibraryVersions();
+      FlushBuffer();
+      lst.append(pybind11::bytes(std::static_pointer_cast<std::stringstream>(stream)->str()));
+      stream = std::make_shared<std::stringstream>();
+      *this & version_runtime;
+      FlushBuffer();
+      lst.append(pybind11::bytes(std::static_pointer_cast<std::stringstream>(stream)->str()));
+      stream = std::make_shared<std::stringstream>();
+      *this & version_needed;
+      FlushBuffer();
+      lst.append(pybind11::bytes(std::static_pointer_cast<std::stringstream>(stream)->str()));
+      return lst;
+    }
+  };
+
+  template<typename T, typename T_ARCHIVE_OUT=BinaryOutArchive, typename T_ARCHIVE_IN=BinaryInArchive>
+  auto NGSPickle()
+  {
+    return pybind11::pickle([](T* self)
+                      {
+                        PyArchive<T_ARCHIVE_OUT> ar;
+                        ar.SetParallel(parallel_pickling);
+                        ar & self;
+                        auto output = pybind11::make_tuple(ar.WriteOut());
+                        return output;
+                      },
+                      [](const pybind11::tuple & state)
+                      {
+                        T* val = nullptr;
+                        PyArchive<T_ARCHIVE_IN> ar(state[0]);
+                        ar & val;
+                        return val;
+                      });
+  }
+
+  template<typename T>
+  Array<T> makeCArray(const py::object& obj)
+  {
+    Array<T> arr;
+    if(py::isinstance<py::list>(obj))
+        for(auto& val : py::cast<py::list>(obj))
+          arr.Append(py::cast<T>(val));
+    else if(py::isinstance<py::tuple>(obj))
+      for(auto& val : py::cast<py::tuple>(obj))
+        arr.Append(py::cast<T>(val));
+    else
+      throw py::type_error("Cannot convert Python object to C Array");
+    return arr;
+  }
+
+  template <typename T>
+  // py::object makePyTuple (FlatArray<T> ar)
+  py::object makePyTuple (const BaseArrayObject<T> & ar)
+  {
+    py::tuple res(ar.Size());
+    for (auto i : Range(ar))
+      res[i] = py::cast(ar[i]);
+    return res;
+  }
+
+  template <typename T, typename TIND=typename FlatArray<T>::index_type>
+  void ExportArray (py::module &m)
+  {
+      using TFlat = FlatArray<T, TIND>;
+      using TArray = Array<T, TIND>;
+      std::string suffix = GetPyName<T>() + "_" +
+        GetPyName<TIND>();
+      std::string fname = std::string("FlatArray_") + suffix;
+      auto flatarray_class = py::class_<TFlat>(m, fname.c_str(),
+                                               py::buffer_protocol())
+        .def ("__len__", [] ( TFlat &self ) { return self.Size(); } )
+        .def ("__getitem__",
+              [](TFlat & self, TIND i) -> T&
+                             {
+                               // static constexpr int base = IndexBASE<TIND>();
+                               auto reli = i - IndexBASE<TIND>();
+                               if (reli < 0 || reli >= self.Size())
+                                 throw py::index_error();
+                               return self[i]; 
+                             },
+              py::return_value_policy::reference)
+        .def ("__setitem__",
+              [](TFlat & self, TIND i, T val) -> T&
+                             {
+                               // static constexpr int base = IndexBASE<TIND>();
+                               auto reli = i - IndexBASE<TIND>();                               
+                               if (reli < 0 || reli >= self.Size())
+                                 throw py::index_error();
+                               self[i] = val;
+                               return self[i];
+                             },
+              py::return_value_policy::reference)
+
+        .def ("__setitem__",
+              [](TFlat & self, py::slice slice, T val)
+              {
+                size_t start, stop, step, slicelength;
+                if (!slice.compute(self.Size(), &start, &stop, &step, &slicelength))
+                  throw py::error_already_set();
+                static constexpr int base = IndexBASE<TIND>();
+                if (start < base || start+(slicelength-1)*step >= self.Size()+base)
+                  throw py::index_error();
+                for (size_t i = 0; i < slicelength; i++, start+=step)
+                  self[start] = val;
+              })
+
+        .def("__iter__", [] ( TFlat & self) {
+             return py::make_iterator (self.begin(),self.end());
+             }, py::keep_alive<0,1>()) // keep array alive while iterator is used
+
+        .def("__str__", [](TFlat& self)
+                        {
+                          return ToString(self);
+                        })
+      ;
+
+      if constexpr (detail::HasPyFormat<T>::value)
+        {
+          if(ngcore_have_numpy && !py::detail::npy_format_descriptor<T>::dtype().is_none())
+            {
+              flatarray_class
+                .def_buffer([](TFlat& self)
+                            {
+                              return py::buffer_info(
+                                self.Addr(0),
+                                sizeof(T),
+                                py::format_descriptor<T>::format(),
+                                1,
+                                { self.Size() },
+                                { sizeof(T) * (self.Addr(1) - self.Addr(0)) });
+                            })
+                .def("NumPy", [](py::object self)
+                              {
+                                return py::module::import("numpy")
+                                  .attr("frombuffer")(self, py::detail::npy_format_descriptor<T>::dtype());
+                              })
+                ;
+              }
+          }
+
+      std::string aname = std::string("Array_") + suffix;
+      auto arr = py::class_<TArray, TFlat> (m, aname.c_str())
+        .def(py::init([] (size_t n) { return new TArray(n); }),py::arg("n"), "Makes array of given length")
+        .def(py::init([] (std::vector<T> const & x)
+                  {
+                    size_t s = x.size();
+                    TArray tmp(s);
+                    for (size_t i : Range(tmp))
+                      tmp[TIND(i)] = x[i];
+                    return tmp;
+                  }), py::arg("vec"), "Makes array with given list of elements")
+        ;
+      if constexpr(is_archivable<TArray>)
+        arr.def(NGSPickle<TArray>());
+      py::implicitly_convertible<std::vector<T>, TArray>();
+    }
+
+  template <typename T>
+  void ExportTable (py::module &m)
+  {
+    py::class_<ngcore::Table<T>, std::shared_ptr<ngcore::Table<T>>> (m, ("Table_"+GetPyName<T>()).c_str())
+      .def(py::init([] (py::list blocks)
+                    {
+                       size_t size = py::len(blocks);
+                       Array<int> cnt(size);
+                       size_t i = 0;
+                       for (auto block : blocks)
+                         cnt[i++] = py::len(block);
+                       
+                       i = 0;
+                       Table<T> blocktable(cnt);
+                       for (auto block : blocks)
+                         {
+                           auto row = blocktable[i++];
+                           size_t j = 0;
+                           for (auto val : block)
+                             row[j++] = val.cast<T>();
+                         }
+                       // cout << "blocktable = " << *blocktable << endl;
+                       return blocktable;
+                      
+                    }), py::arg("blocks"), "a list of lists")
+
+      .def ("__len__", [] (Table<T> &self ) { return self.Size(); } )
+      .def ("__getitem__",
+            [](Table<T> & self, size_t i) -> FlatArray<T>
+            {
+              if (i >= self.Size())
+                throw py::index_error();
+              return self[i]; 
+            })
+      .def("__str__", [](Table<T> & self)
+           {
+             return ToString(self);
+           })
+      ;
+  }
+
+  
+  void NGCORE_API SetFlag(Flags &flags, std::string s, py::object value);
+  // Parse python kwargs to flags
+  Flags NGCORE_API CreateFlagsFromKwArgs(const py::kwargs& kwargs, py::object pyclass = py::none(),
+                                         py::list info = py::list());
+  // Create python dict from kwargs
+  py::dict NGCORE_API CreateDictFromFlags(const Flags& flags);
+
+
+} // namespace ngcore
+
+#endif // NETGEN_CORE_PYTHON_NGCORE_HPP

netgen/include/core/ranges.hpp

@@ -0,0 +1,109 @@
+#ifndef NETGEN_CORE_RANGES_HPP
+#define NETGEN_CORE_RANGES_HPP
+
+#include <iterator>
+
+namespace ngcore
+{
+  template<typename Iterator>
+  class AdapterRange
+  {
+    Iterator _begin,_end;
+  public:
+    AdapterRange(Iterator abegin, Iterator aend) : _begin(abegin), _end(aend) { ; }
+    Iterator begin() const { return _begin; }
+    Iterator end() const { return _end; }
+  };
+
+  template<typename FUNC>
+  class FilterAdapter
+  {
+    FUNC f;
+  public:
+    FilterAdapter(FUNC af) : f(af) { ; }
+    FUNC GetFunction() const { return f; }
+  };
+
+  template<typename FUNC, typename Iterator>
+  class FilterIterator
+  {
+    Iterator iter;
+    Iterator end;
+    FUNC f;
+  public:
+    FilterIterator(FUNC af, Iterator aiter, Iterator aend)
+      :  iter(aiter), end(aend), f(af)
+    {
+      while(iter!=end && !f(*iter))
+        ++iter;
+    }
+    inline FilterIterator& operator ++()
+    {
+      ++iter;
+      while(iter!=end && !f(*iter))
+        ++iter;
+      return *this;
+    }
+
+    inline bool operator !=(FilterIterator other)
+    {
+      return iter != other.iter;
+    }
+
+    inline bool operator ==(FilterIterator other)
+    {
+      return iter == other.iter;
+    }
+
+    inline decltype(auto) operator *() const
+    {
+      return *iter;
+    }
+  };
+
+  template<typename FUNC>
+  FilterAdapter<FUNC> filter(FUNC f) { return {f}; }
+
+  template<typename Range, typename FUNC>
+  auto operator |(Range&& range, FilterAdapter<FUNC> adapter)
+    -> AdapterRange<FilterIterator<FUNC,decltype(std::begin(range))>>
+  {
+    return {{adapter.GetFunction(),std::begin(range),std::end(range)},
+        {adapter.GetFunction(), std::end(range), std::end(range)}};
+  }
+
+  template<typename FUNC, typename Iterator>
+  class TransformIterator
+  {
+    FUNC f;
+    Iterator iter;
+  public:
+    TransformIterator(FUNC af, Iterator aiter) : f(af), iter(aiter) { ; }
+
+    TransformIterator& operator++() { ++iter; }
+    bool operator !=(TransformIterator other) { return iter != other.iter; }
+    decltype(auto) operator *() const { return f(*iter); }
+  };
+
+  template<typename FUNC>
+  class TransformAdapter
+  {
+    FUNC f;
+  public:
+    TransformAdapter(FUNC af) : f(af) { ; }
+    FUNC GetFunction() const { return f; }
+  };
+
+  template<typename FUNC>
+  TransformAdapter<FUNC> transform(FUNC f) { return {f}; }
+
+  template<typename Range, typename FUNC>
+  auto operator |(Range&& range, TransformAdapter<FUNC> adapter)
+    -> AdapterRange<TransformIterator<FUNC,decltype(std::begin(range))>>
+  {
+    return {{adapter.GetFunction(), std::begin(range)},
+        {adapter.GetFunction(),std::end(range)}};
+  }
+} // namespace ngcore
+
+#endif // NETGEN_CORE_RANGES_HPP

netgen/include/core/register_archive.hpp

@@ -0,0 +1,100 @@
+#ifndef NETGEN_REGISTER_ARCHIVE_HPP
+#define NETGEN_REGISTER_ARCHIVE_HPP
+
+#ifdef NETGEN_PYTHON
+#include <memory>
+#include <pybind11/pybind11.h>
+#include <pybind11/cast.h>
+#endif // NETGEN_PYTHON
+#include <tuple>
+
+#include "archive.hpp"
+
+namespace ngcore {
+  // ***************  Archiving functionality  **************
+
+#ifdef NETGEN_PYTHON
+  template<typename T>
+  Archive& Archive :: Shallow(T& val)
+  {
+    static_assert(detail::is_any_pointer<T>, "ShallowArchive must be given pointer type!");
+    if(shallow_to_python)
+      {
+        if(is_output)
+          ShallowOutPython(pybind11::cast(val));
+        else
+        {
+          pybind11::object obj;
+          ShallowInPython(obj);
+          val = pybind11::cast<T>(obj);
+        }
+      }
+    else
+      *this & val;
+    return *this;
+  }
+
+  /*
+    // now using has_shared_from_this2 in archive.hpp
+  template <typename T>
+  struct has_shared_from_this
+  {
+    template <typename C> static std::true_type check( decltype( sizeof(&C::shared_from_this )) ) { return std::true_type(); }
+    template <typename> static std::false_type check(...) { return std::false_type(); }
+    typedef decltype( check<T>(sizeof(char)) ) type;
+    static constexpr type value = type();
+  };
+  */
+#endif // NETGEN_PYTHON
+
+
+  template<typename T, typename Bases=std::tuple<>>
+  class RegisterClassForArchive
+  {
+  public:
+    RegisterClassForArchive()
+    {
+      static_assert(std::is_base_of<Bases, T>::value ||
+                    detail::is_base_of_tuple<T, Bases>,
+                    "Second argument must be base class or tuple of base classes of T");
+      detail::ClassArchiveInfo info {};
+      info.creator = [](const std::type_info& ti, Archive& ar) -> void*
+      {
+        detail::TCargs<T> args;
+        ar &args;
+        auto nT = detail::constructIfPossible<T>(std::move(args));
+        return typeid(T) == ti ? nT
+          : Archive::Caster<T, Bases>::tryUpcast(ti, nT);
+      };
+      info.upcaster = [](const std::type_info& ti, void* p) -> void*
+      { return typeid(T) == ti ? p : Archive::Caster<T, Bases>::tryUpcast(ti, static_cast<T*>(p)); };
+      info.downcaster = [](const std::type_info& ti, void* p) -> void*
+      { return typeid(T) == ti ? p : Archive::Caster<T, Bases>::tryDowncast(ti, p); };
+      info.cargs_archiver = [](Archive &ar, void* p) {
+        if constexpr(detail::has_GetCArgs_v<T>)
+          ar << static_cast<T*>(p)->GetCArgs();
+      };
+#ifdef NETGEN_PYTHON
+    info.anyToPyCaster = [](const std::any &a) {
+      if constexpr(has_shared_from_this2<T>::value) {
+        std::shared_ptr<T> val = std::any_cast<std::shared_ptr<T>>(a);
+        return pybind11::cast(val);
+      } else {
+        const T* val = std::any_cast<T>(&a);
+        return pybind11::cast(val);
+      }
+    };
+    info.pyToAnyCaster = [](pybind11::object &obj)
+    {
+      if constexpr(has_shared_from_this2<T>::value || !std::is_copy_constructible<T>::value)
+        return std::any { obj.cast<std::shared_ptr<T>>() };
+      else
+        return std::any { obj.cast<T>() };
+    };
+
+#endif // NETGEN_PYTHON
+    Archive::SetArchiveRegister(std::string(Demangle(typeid(T).name())),info);
+  }
+};
+} // namespace ngcore
+#endif // NETGEN_REGISTER_ARCHIVE_HPP