From 493372904160c195a2e0570ba4ae6f048a537204 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Thu, 15 May 2025 23:22:57 -0400
Subject: [PATCH 01/22] Implements C++ -> Python bridge for Adiak's annotation
 APIs

---
 src/interface/python/common.hpp  |   9 +
 src/interface/python/pyadiak.cpp | 319 +++++++++++++++++++++++++++++++
 src/interface/python/pyadiak.hpp |  14 ++
 3 files changed, 342 insertions(+)
 create mode 100644 src/interface/python/common.hpp
 create mode 100644 src/interface/python/pyadiak.cpp
 create mode 100644 src/interface/python/pyadiak.hpp

diff --git a/src/interface/python/common.hpp b/src/interface/python/common.hpp
new file mode 100644
index 0000000..4103d65
--- /dev/null
+++ b/src/interface/python/common.hpp
@@ -0,0 +1,9 @@
+#ifndef ADIAK_INTERFACE_PYTHON_COMMON_HPP_
+#define ADIAK_INTERFACE_PYTHON_COMMON_HPP_
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+#endif /* ADIAK_INTERFACE_PYTHON_COMMON_HPP_ */
\ No newline at end of file
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
new file mode 100644
index 0000000..1e44651
--- /dev/null
+++ b/src/interface/python/pyadiak.cpp
@@ -0,0 +1,319 @@
+#include "pyadiak.hpp"
+#include "adiak.hpp"
+#include <mpi.h>
+#include <mpi4py/mpi4py.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdint>
+#include <set>
+#include <type_traits>
+
+namespace adiak {
+namespace python {
+
+// Bindings for MPI Comm derived from this StackOverflow post:
+// https://stackoverflow.com/a/62449190
+struct mpi4py_comm {
+  mpi4py_comm() = default;
+
+  mpi4py_comm(MPI_Comm comm) : m_comm(comm) {}
+
+  MPI_Comm m_comm;
+};
+
+namespace pybind11 {
+namespace detail {
+
+template <> struct type_caster<mpi4py_comm> {
+  PYBIND11_TYPE_CASTER(mpi4py_comm, _("mpi4py_comm"));
+
+  bool load(py::handle src, bool) {
+    // If the comm is None, produce a mpi4py_comm object with m_comm set to
+    // MPI_COMM_NULL
+    if (src == py::none()) {
+      value.m_comm = MPI_COMM_NULL;
+      return !PyErr_Occured();
+    }
+    // Get the underlying PyObject pointer to the mpi4py object
+    PyObject *py_capi_comm = src.ptr();
+    // Make sure the PyObject pointer's underlying type is mpi4py's
+    // PyMPIComm_Type. If the type check passes, use PyMPIComm_Get (from
+    // mpi4py's C API) to get the actual MPI_Comm. If the type check fails, tell
+    // pybind11 that the conversion is invalid.
+    if (PyObject_TypeCheck(py_capi_comm, &PyMPIComm_Type)) {
+      value.m_comm = *PyMPIComm_Get(py_capi_comm);
+    } else {
+      return false;
+    }
+    // Tell pybind11 that the conversion to C++ was successfull so long as there
+    // were no Python errors
+    return !PyErr_Occured();
+  }
+
+  static py::handle cast(mpi4py_comm src, py::return_value_policy, py::handle) {
+    return PyMPIComm_New(src.m_comm);
+  }
+};
+
+} // namespace detail
+} // namespace pybind11
+
+// The 'is_templated_base_of' type trait is derived from the following
+// StackOverflow post:
+// https://stackoverflow.com/a/49163138
+template <template <typename...> class Base, typename Derived,
+          typename TCheck = void>
+struct is_templated_base_of_tester;
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
+  template <typename... T> static constexpr std::true_type test(Base<T...> *);
+  static constexpr std::false_type test(...);
+  using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
+};
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
+  using is_base = std::false_type;
+};
+
+template <template <typename...> class Base, typename Derived>
+using is_templated_base_of =
+    typename is_templated_base_of_tester<Base, Derived>::is_base;
+
+template <typename T, class adiak_type> struct DataContainer {
+  T m_v;
+
+  DataContainer(T val) : m_v(val) {}
+
+  virtual adiak_type to_adiak() const = 0;
+};
+
+// Python-compatible struct for storing timepoint info
+// that will be converted into 'struct timeval' for Adiak
+struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
+                                        struct timeval *> {
+  struct timeval m_time_for_adiak;
+
+  Timepoint(std::chrono::system_clock::time_point time)
+      : DataContainer<std::chrono::system_clock::time_point, struct timeval *>(
+            time) {}
+
+  struct timeval *to_adiak() const final {
+    auto time_since_epoch =
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            m_v.time_since_epoch());
+    m_time_for_adiak.tv_sec = time_since_epoch.count() / 1000000;
+    m_time_for_adiak.tv_usec = time_since_epoch.count() % 1000000;
+    return &m_time_for_adiak;
+  }
+};
+
+// Python-compatible struct for storing date or datetime info
+// that will be converted into 'adiak::date' for Adiak
+struct Date
+    : public DataContainer<std::chrono::system_clock::time_point, adiak::date> {
+  Date(std::chrono::system_clock::time_point time)
+      : DataContainer<std::chrono::system_clock::time_point, adiak::date>(
+            time) {}
+
+  adiak::date to_adiak() const final {
+    auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
+        value.time_since_epoch());
+    return adiak::date(time_since_epoch.count());
+  }
+};
+
+// Python-compatible struct for storing version info
+// that will be converted into 'adiak::version' for Adiak
+struct Version : public DataContainer<std::string, adiak::version> {
+  Version(const std::string &ver)
+      : DataContainer<std::string, adiak::version>(ver) {}
+
+  adiak::version to_adiak() const final { return adiak::version(m_v); }
+};
+
+// TODO replace use of string with std::filesystem if/when C++17 is supported
+// Python-compatible struct for storing path info
+// that will be converted into 'adiak::path' for Adiak
+struct Path : public DataContainer<std::string, adiak::path> {
+  Path(const std::string &p) : DataContainer<std::string, adiak::path>(p) {}
+
+  adiak::path to_adiak() const final { return adiak::path(m_v); }
+};
+
+// Python-compatible struct for storing categorical string info
+// that will be converted into 'adiak::catstring' for Adiak
+struct CatStr : public DataContainer<std::string, adiak::catstring> {
+  CatStr(const std::string &cs)
+      : DataContainer<std::string, adiak::catstring>(cs) {}
+
+  adiak::catstring to_adiak() const { return adiak::catstring(m_v); }
+};
+
+// Python-compatible struct for storing JSON string info
+// that will be converted into 'adiak::jsonstring' for Adiak
+struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
+  JsonStr(const std::string &js)
+      : DataContainer<std::string, adiak::jsonstring>(js) {}
+
+  adiak::jsonstring to_adiak() const { return adiak::jsonstring(m_v); }
+};
+
+// Custom wrapper for adiak::init
+// The only difference is that it uses the behavior of the pybind11
+// type_caster above to decide whether to pass an MPI communicator
+// to adiak::init
+void init(mpi4py_comm comm) {
+  if (comm.m_comm == MPI_COMM_NULL) {
+    adiak::init(nullptr);
+  } else {
+    adiak::init(&comm.m_comm);
+  }
+}
+
+// Custom version of adiak::value for subclasses of DataContainer
+template <class T, typename = std::enable_if_t<
+                       std::is_templated_base_of<DataContainer, T>::value>>
+bool value(std::string name, T value, int category = adiak_general,
+           std::string subcategory = "") {
+  return adiak::value(name, value.to_adiak(), category, subcategory);
+}
+
+// Custom version of adiak::value for vectors of subclasses of DataContainer
+template <class T, typename = std::enable_if_t<
+                       std::is_templated_base_of<DataContainer, T>::value>>
+bool value_vec(std::string name, std::vector<T> value,
+               int category = adiak_general, std::string subcategory = "") {
+  std::vector<std::result_of<decltype (&T::to_adiak)()>::type> adiak_vec;
+  std::transform(value.cbegin(), value.cend(), adiak_vec.cbegin(),
+                 [](T v) { return v.to_adiak(); });
+  return adiak::value(name, adiak_vec, category, subcategory);
+}
+
+// Custom version of adiak::value for sets of subclasses of DataContainer
+template <class T, typename = std::enable_if_t<
+                       std::is_templated_base_of<DataContainer, T>::value>>
+bool value_set(std::string name, std::set<T> value,
+               int category = adiak_general, std::string subcategory = "") {
+  std::set<std::result_of<decltype (&T::to_adiak)()>::type> adiak_set;
+  std::transform(value.cbegin(), value.cend(), adiak_set.cbegin(),
+                 [](T v) { return v.to_adiak(); });
+  return adiak::value(name, adiak_set, category, subcategory);
+}
+
+// Macros to help generate the lambdas that pybind11 needs to bind the inline
+// functions in adiak.hpp
+//
+// clang-format off
+#define GENERATE_API_CALL_NO_ARGS(name)                                                \
+  [](){ return adiak::name(); }
+#define GENERATE_API_CALL_ONE_ARG(name, arg_type) [](arg_type val){ return adiak::name(val); }
+// clang-format on
+
+// Function to populate the Python module
+void create_adiak_annotation_mod(py::module_ &mod) {
+  // Try to import mpi4py so that we can early abort if
+  // we can't properly create bindings
+  if (import_mpi4py() < 0) {
+    throw std::runtime_error(
+        "Cannot load mpi4py within the Adiak Python bindings");
+  }
+
+  // Bind the custom data containers to Python.
+  // Note that we don't wrap the DataContainer base class or the 'to_adiak'
+  // methods because we don't need those exposed to Python.
+  py::class_<adiak::python::Timepoint>(mod, "Timepoint")
+      .def(py::init<std::chrono::system_clock::time_point>());
+  py::class_<adiak::python::Date>(mod, "Date")
+      .def(py::init<std::chrono::system_clock::time_point>());
+  py::class_<adiak::python::Version>(mod, "Version")
+      .def(py::init<const std::string &>());
+  py::class_<adiak::python::Path>(mod, "Path")
+      .def(py::init<const std::string &>());
+  py::class_<adiak::python::CatStr>(mod, "CatStr")
+      .def(py::init<const std::string &>());
+  py::class_<adiak::python::JsonStr>(mod, "JsonStr")
+      .def(py::init<const std::string &>());
+
+  // Bind 'init' and 'fini'
+  mod.def("init", &adiak::python::init);
+  mod.def("fini", GENERATE_API_CALL_NO_ARGS(fini));
+  // Python has no concept of templates, so pybind11 requires
+  // us to specify the types for all template functions. The requires us to
+  // iterate over all acceptable value types for adiak::value.
+  //
+  // Because we need to use Python-compatible types everywhere,
+  // we use special wrappers for types not natively supported by pybind11.
+  // To bridge these types to Adiak, we use custom versions of "value".
+  //
+  // We map all these specializations to the Python "value" function.
+  // Pybind11 will do the work of selecting the correct version of this
+  // function for us.
+  mod.def("value", &adiak::value<int8_t>);
+  mod.def("value", &adiak::value<uint64_t>);
+  mod.def("value", &adiak::value<double>);
+  mod.def("value", &adiak::value<std::string>);
+  mod.def("value", &adiak::python::value<adiak::python::Timepoint>);
+  mod.def("value", &adiak::python::value<adiak::python::Date>);
+  mod.def("value", &adiak::python::value<adiak::python::Version>);
+  mod.def("value", &adiak::python::value<adiak::python::Path>);
+  mod.def("value", &adiak::python::value<adiak::python::CatStr>);
+  mod.def("value", &adiak::python::value<adiak::python::JsonStr>);
+  mod.def("value", &adiak::value<std::vector<int8_t>>);
+  mod.def("value", &adiak::value<std::vector<uint64_t>>);
+  mod.def("value", &adiak::value<std::vector<double>>);
+  mod.def("value", &adiak::value<std::vector<std::string>>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::Timepoint>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::Date>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::Version>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::Path>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::CatStr>);
+  mod.def("value", &adiak::python::value_vec<adiak::python::JsonStr>);
+  mod.def("value", &adiak::value<std::set<int8_t>>);
+  mod.def("value", &adiak::value<std::set<uint64_t>>);
+  mod.def("value", &adiak::value<std::set<double>>);
+  mod.def("value", &adiak::value<std::set<std::string>>);
+  mod.def("value", &adiak::python::value_set<adiak::python::Timepoint>);
+  mod.def("value", &adiak::python::value_set<adiak::python::Date>);
+  mod.def("value", &adiak::python::value_set<adiak::python::Version>);
+  mod.def("value", &adiak::python::value_set<adiak::python::Path>);
+  mod.def("value", &adiak::python::value_set<adiak::python::CatStr>);
+  mod.def("value", &adiak::python::value_set<adiak::python::JsonStr>);
+
+  // Bind all the other Adiak functions to custom lambda functions
+  // created by the GENERATE_API_CALL_* macros. These labmdas are
+  // used over the plain versions of these functions to avoid any issues
+  // with those functions being marked 'inline'.
+  mod.def("adiakversion", GENERATE_API_CALL_NO_ARGS(adiakversion));
+  mod.def("user", GENERATE_API_CALL_NO_ARGS(user));
+  mod.def("uid", GENERATE_API_CALL_NO_ARGS(uid));
+  mod.def("launchdate", GENERATE_API_CALL_NO_ARGS(launchdate));
+  mod.def("launchday", GENERATE_API_CALL_NO_ARGS(launchday));
+  mod.def("executable", GENERATE_API_CALL_NO_ARGS(executable));
+  mod.def("executablepath", GENERATE_API_CALL_NO_ARGS(executablepath));
+  mod.def("workdir", GENERATE_API_CALL_NO_ARGS(workdir));
+  mod.def("libraries", GENERATE_API_CALL_NO_ARGS(libraries));
+  mod.def("cmdline", GENERATE_API_CALL_NO_ARGS(cmdline));
+  mod.def("hostname", GENERATE_API_CALL_NO_ARGS(hostname));
+  mod.def("clustername", GENERATE_API_CALL_NO_ARGS(clustername));
+  mod.def("walltime", GENERATE_API_CALL_NO_ARGS(walltime));
+  mod.def("systime", GENERATE_API_CALL_NO_ARGS(systime));
+  mod.def("cputime", GENERATE_API_CALL_NO_ARGS(cputime));
+  mod.def("jobsize", GENERATE_API_CALL_NO_ARGS(jobsize));
+  mod.def("hostlist", GENERATE_API_CALL_NO_ARGS(hostlist));
+  mod.def("numhosts", GENERATE_API_CALL_NO_ARGS(numhosts));
+  mod.def("mpi_version", GENERATE_API_CALL_NO_ARGS(mpi_version));
+  mod.def("mpi_library", GENERATE_API_CALL_NO_ARGS(mpi_library));
+  mod.def("mpi_library_version",
+          GENERATE_API_CALL_NO_ARGS(mpi_library_version));
+  mod.def("flush", GENERATE_API_CALL_ONE_ARG(flush, std::string));
+  mod.def("clean", GENERATE_API_CALL_NO_ARGS(clean));
+  mod.def("collect_all", GENERATE_API_CALL_NO_ARGS(collect_all));
+}
+
+} // namespace python
+} // namespace adiak
\ No newline at end of file
diff --git a/src/interface/python/pyadiak.hpp b/src/interface/python/pyadiak.hpp
new file mode 100644
index 0000000..39d4051
--- /dev/null
+++ b/src/interface/python/pyadiak.hpp
@@ -0,0 +1,14 @@
+#ifndef ADIAK_INTERFACE_PYTHON_ADIAK_HPP_
+#define ADIAK_INTERFACE_PYTHON_ADIAK_HPP_
+
+#include "common"
+
+namespace adiak {
+namespace python {
+
+void create_adiak_annotation_mod(py::module_ &mod);
+
+}
+} // namespace adiak
+
+#endif /* ADIAK_INTERFACE_PYTHON_ADIAK_HPP_ */

From ed20c530b12eab98c9878ea61ca1488ee4ca7dbb Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Thu, 15 May 2025 23:50:09 -0400
Subject: [PATCH 02/22] Current progress on the tools interface

---
 src/interface/python/pyadiak.hpp      |  6 ++--
 src/interface/python/pyadiak_tool.cpp | 48 +++++++++++++++++++++++++++
 src/interface/python/pyadiak_tool.hpp | 14 ++++++++
 3 files changed, 65 insertions(+), 3 deletions(-)
 create mode 100644 src/interface/python/pyadiak_tool.cpp
 create mode 100644 src/interface/python/pyadiak_tool.hpp

diff --git a/src/interface/python/pyadiak.hpp b/src/interface/python/pyadiak.hpp
index 39d4051..8e7d9a1 100644
--- a/src/interface/python/pyadiak.hpp
+++ b/src/interface/python/pyadiak.hpp
@@ -1,5 +1,5 @@
-#ifndef ADIAK_INTERFACE_PYTHON_ADIAK_HPP_
-#define ADIAK_INTERFACE_PYTHON_ADIAK_HPP_
+#ifndef ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
+#define ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
 
 #include "common"
 
@@ -11,4 +11,4 @@ void create_adiak_annotation_mod(py::module_ &mod);
 }
 } // namespace adiak
 
-#endif /* ADIAK_INTERFACE_PYTHON_ADIAK_HPP_ */
+#endif /* ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_ */
diff --git a/src/interface/python/pyadiak_tool.cpp b/src/interface/python/pyadiak_tool.cpp
new file mode 100644
index 0000000..bef7d0e
--- /dev/null
+++ b/src/interface/python/pyadiak_tool.cpp
@@ -0,0 +1,48 @@
+#include "pyadiak_tool.hpp"
+#include "adiak_tool.h"
+
+namespace adiak {
+namespace python {
+
+void pyadiak_tool_nameval_cb(const char *name, int category,
+                             const char *subcategory, adiak_value_t *value,
+                             adiak_datatype_t *t, void *py_cb) {
+  py::handle nv_cb((PyObject *)py_cb);
+  // TODO add any necessary conversion from adiak_value_t and adiak_datatype_t
+  // to correct Python-compatible types
+  nv_cb(name, category, subcategory, value, t);
+}
+
+void pyadiak_register_cb(int adiak_version, int category, py::function nv_cb,
+                         bool report_on_all_ranks) {
+  PyObject *nv_cb_obj = nv_cb.ptr();
+  Py_INCREF(nv_cb_obj);
+  adiak_register_cb(adiak_version, category, pyadiak_tool_nameval_cb,
+                    report_on_all_ranks ? 1 : 0, (void *)nv_cb_obj);
+}
+
+void pyadiak_list_namevals(int adiak_version, int category,
+                           py::function nv_cb) {
+  PyObject *nv_cb_obj = nv_cb.ptr();
+  Py_INCREF(nv_cb_obj);
+  adiak_list_namevals(adiak_version, category, pyadiak_tool_nameval_cb,
+                      (void *)nv_cb_obj);
+}
+
+std::string pyadiak_type_to_string(adiak_datatype_t *t, bool long_form) {
+  // TODO implement once I figure out how to handle dtypes
+  return std::string("");
+}
+
+std::tuple<adiak_datatype_t *, adiak_value_t *, int, const char *>
+pyadiak_get_nameval(const char *name) {
+  // TODO implement once I figure out how to handle dtypes and values
+}
+
+int pyadiak_num_subvals(adiak_datatype_t *t) {
+  // TODO implement once I figure out how to handle dtypes
+  return 0;
+}
+
+} // namespace python
+} // namespace adiak
diff --git a/src/interface/python/pyadiak_tool.hpp b/src/interface/python/pyadiak_tool.hpp
new file mode 100644
index 0000000..3b82d02
--- /dev/null
+++ b/src/interface/python/pyadiak_tool.hpp
@@ -0,0 +1,14 @@
+#ifndef ADIAK_INTERFACE_PYTHON_PYADIAK_TOOL_HPP_
+#define ADIAK_INTERFACE_PYTHON_PYADIAK_TOOL_HPP_
+
+#include "common.hpp"
+
+namespace adiak {
+namespace python {
+
+void create_adiak_tool_annotation_mod(py::module_ &mod);
+
+}
+} // namespace adiak
+
+#endif /* ADIAK_INTERFACE_PYTHON_PYADIAK_TOOL_HPP_*/
\ No newline at end of file

From a5e43cb18730c54e5c699d35a60e292086eb48b6 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Fri, 16 May 2025 11:21:45 -0400
Subject: [PATCH 03/22] Finishes implementation of C++ -> Python bridge

---
 src/interface/python/mod.cpp          |  13 ++
 src/interface/python/pyadiak.cpp      | 144 +++++----------
 src/interface/python/pyadiak.hpp      |  95 +++++++++-
 src/interface/python/pyadiak_tool.cpp | 246 ++++++++++++++++++++++++--
 src/interface/python/pyadiak_tool.hpp |   2 +-
 5 files changed, 385 insertions(+), 115 deletions(-)
 create mode 100644 src/interface/python/mod.cpp

diff --git a/src/interface/python/mod.cpp b/src/interface/python/mod.cpp
new file mode 100644
index 0000000..aa4672c
--- /dev/null
+++ b/src/interface/python/mod.cpp
@@ -0,0 +1,13 @@
+#include "pyadiak.hpp"
+#include "pyadiak_tool.hpp"
+
+PYBIND11_MODULE(__pyadiak_impl, m) {
+  // TODO add version
+
+  auto annotation_module =
+      m.def_submodule("annotation", "Submodule for annotation APIs");
+  adiak::python::create_adiak_annotation_mod(annotation_module);
+
+  auto tool_module = m.def_submodule("tool", "Submodule for tool APIs");
+  adiak::python::create_adiak_tool_mod(tool_module);
+}
\ No newline at end of file
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index 1e44651..fb9ab71 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -4,13 +4,8 @@
 #include <mpi4py/mpi4py.h>
 
 #include <algorithm>
-#include <chrono>
 #include <cstdint>
 #include <set>
-#include <type_traits>
-
-namespace adiak {
-namespace python {
 
 // Bindings for MPI Comm derived from this StackOverflow post:
 // https://stackoverflow.com/a/62449190
@@ -59,109 +54,50 @@ template <> struct type_caster<mpi4py_comm> {
 } // namespace detail
 } // namespace pybind11
 
-// The 'is_templated_base_of' type trait is derived from the following
-// StackOverflow post:
-// https://stackoverflow.com/a/49163138
-template <template <typename...> class Base, typename Derived,
-          typename TCheck = void>
-struct is_templated_base_of_tester;
-
-template <template <typename...> class Base, typename Derived>
-struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
-  template <typename... T> static constexpr std::true_type test(Base<T...> *);
-  static constexpr std::false_type test(...);
-  using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
-};
-
-template <template <typename...> class Base, typename Derived>
-struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
-  using is_base = std::false_type;
-};
-
-template <template <typename...> class Base, typename Derived>
-using is_templated_base_of =
-    typename is_templated_base_of_tester<Base, Derived>::is_base;
+namespace adiak {
+namespace python {
 
-template <typename T, class adiak_type> struct DataContainer {
-  T m_v;
+Timepoint::Timepoint(std::chrono::system_clock::time_point time)
+    : DataContainer<std::chrono::system_clock::time_point, struct timeval *>(
+          time) {}
 
-  DataContainer(T val) : m_v(val) {}
+struct timeval *Timepoint::to_adiak() const {
+  auto time_since_epoch = std::chrono::duration_cast<std::chrono::microseconds>(
+      m_v.time_since_epoch());
+  m_time_for_adiak.tv_sec = time_since_epoch.count() / 1000000;
+  m_time_for_adiak.tv_usec = time_since_epoch.count() % 1000000;
+  return &m_time_for_adiak;
+}
 
-  virtual adiak_type to_adiak() const = 0;
-};
+Date::Date(std::chrono::system_clock::time_point time)
+    : DataContainer<std::chrono::system_clock::time_point, adiak::date>(time) {}
 
-// Python-compatible struct for storing timepoint info
-// that will be converted into 'struct timeval' for Adiak
-struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
-                                        struct timeval *> {
-  struct timeval m_time_for_adiak;
-
-  Timepoint(std::chrono::system_clock::time_point time)
-      : DataContainer<std::chrono::system_clock::time_point, struct timeval *>(
-            time) {}
-
-  struct timeval *to_adiak() const final {
-    auto time_since_epoch =
-        std::chrono::duration_cast<std::chrono::microseconds>(
-            m_v.time_since_epoch());
-    m_time_for_adiak.tv_sec = time_since_epoch.count() / 1000000;
-    m_time_for_adiak.tv_usec = time_since_epoch.count() % 1000000;
-    return &m_time_for_adiak;
-  }
-};
+adiak::date Date::to_adiak() const {
+  auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
+      value.time_since_epoch());
+  return adiak::date(time_since_epoch.count());
+}
 
-// Python-compatible struct for storing date or datetime info
-// that will be converted into 'adiak::date' for Adiak
-struct Date
-    : public DataContainer<std::chrono::system_clock::time_point, adiak::date> {
-  Date(std::chrono::system_clock::time_point time)
-      : DataContainer<std::chrono::system_clock::time_point, adiak::date>(
-            time) {}
-
-  adiak::date to_adiak() const final {
-    auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
-        value.time_since_epoch());
-    return adiak::date(time_since_epoch.count());
-  }
-};
+Version::Version(const std::string &ver)
+    : DataContainer<std::string, adiak::version>(ver) {}
 
-// Python-compatible struct for storing version info
-// that will be converted into 'adiak::version' for Adiak
-struct Version : public DataContainer<std::string, adiak::version> {
-  Version(const std::string &ver)
-      : DataContainer<std::string, adiak::version>(ver) {}
+adiak::version Version::to_adiak() const { return adiak::version(m_v); }
 
-  adiak::version to_adiak() const final { return adiak::version(m_v); }
-};
+Path::Path(const std::string &p) : DataContainer<std::string, adiak::path>(p) {}
 
-// TODO replace use of string with std::filesystem if/when C++17 is supported
-// Python-compatible struct for storing path info
-// that will be converted into 'adiak::path' for Adiak
-struct Path : public DataContainer<std::string, adiak::path> {
-  Path(const std::string &p) : DataContainer<std::string, adiak::path>(p) {}
+adiak::path Path::to_adiak() const { return adiak::path(m_v); }
 
-  adiak::path to_adiak() const final { return adiak::path(m_v); }
-};
+CatStr::CatStr(const std::string &cs)
+    : DataContainer<std::string, adiak::catstring>(cs) {}
 
-// Python-compatible struct for storing categorical string info
-// that will be converted into 'adiak::catstring' for Adiak
-struct CatStr : public DataContainer<std::string, adiak::catstring> {
-  CatStr(const std::string &cs)
-      : DataContainer<std::string, adiak::catstring>(cs) {}
+adiak::catstringCatStr::to_adiak() const { return adiak::catstring(m_v); }
 
-  adiak::catstring to_adiak() const { return adiak::catstring(m_v); }
-};
+CatStr::to_adiak() const { return adiak::catstring(m_v); }
 
-// Python-compatible struct for storing JSON string info
-// that will be converted into 'adiak::jsonstring' for Adiak
-struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
-  JsonStr(const std::string &js)
-      : DataContainer<std::string, adiak::jsonstring>(js) {}
+JsonStr::JsonStr(const std::string &js)
+    : DataContainer<std::string, adiak::jsonstring>(js) {}
 
-  adiak::jsonstring to_adiak() const { return adiak::jsonstring(m_v); }
-};
+adiak::jsonstring JsonStr::to_adiak() const { return adiak::jsonstring(m_v); }
 
 // Custom wrapper for adiak::init
 // The only difference is that it uses the behavior of the pybind11
@@ -227,17 +163,23 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   // Note that we don't wrap the DataContainer base class or the 'to_adiak'
   // methods because we don't need those exposed to Python.
   py::class_<adiak::python::Timepoint>(mod, "Timepoint")
-      .def(py::init<std::chrono::system_clock::time_point>());
+      .def(py::init<std::chrono::system_clock::time_point>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::Date>(mod, "Date")
-      .def(py::init<std::chrono::system_clock::time_point>());
+      .def(py::init<std::chrono::system_clock::time_point>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::Version>(mod, "Version")
-      .def(py::init<const std::string &>());
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::Path>(mod, "Path")
-      .def(py::init<const std::string &>());
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::CatStr>(mod, "CatStr")
-      .def(py::init<const std::string &>());
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::JsonStr>(mod, "JsonStr")
-      .def(py::init<const std::string &>());
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
 
   // Bind 'init' and 'fini'
   mod.def("init", &adiak::python::init);
diff --git a/src/interface/python/pyadiak.hpp b/src/interface/python/pyadiak.hpp
index 8e7d9a1..c628113 100644
--- a/src/interface/python/pyadiak.hpp
+++ b/src/interface/python/pyadiak.hpp
@@ -1,14 +1,105 @@
 #ifndef ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
 #define ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
 
-#include "common"
+#include "common.hpp"
+
+#include <chrono>
+#include <type_traits>
 
 namespace adiak {
 namespace python {
 
+// The 'is_templated_base_of' type trait is derived from the following
+// StackOverflow post:
+// https://stackoverflow.com/a/49163138
+template <template <typename...> class Base, typename Derived,
+          typename TCheck = void>
+struct is_templated_base_of_tester;
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
+  template <typename... T> static constexpr std::true_type test(Base<T...> *);
+  static constexpr std::false_type test(...);
+  using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
+};
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
+  using is_base = std::false_type;
+};
+
+template <template <typename...> class Base, typename Derived>
+using is_templated_base_of =
+    typename is_templated_base_of_tester<Base, Derived>::is_base;
+
+template <typename T, class adiak_type> struct DataContainer {
+  T m_v;
+
+  DataContainer(T val) : m_v(val) {}
+
+  virtual T to_python() const { return m_v; }
+
+  virtual adiak_type to_adiak() const = 0;
+};
+
+// Python-compatible struct for storing timepoint info
+// that will be converted into 'struct timeval' for Adiak
+struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
+                                        struct timeval *> {
+  struct timeval m_time_for_adiak;
+
+  Timepoint(std::chrono::system_clock::time_point time);
+
+  struct timeval *to_adiak() const final;
+};
+
+// Python-compatible struct for storing date or datetime info
+// that will be converted into 'adiak::date' for Adiak
+struct Date
+    : public DataContainer<std::chrono::system_clock::time_point, adiak::date> {
+  Date(std::chrono::system_clock::time_point time);
+
+  adiak::date to_adiak() const final;
+};
+
+// Python-compatible struct for storing version info
+// that will be converted into 'adiak::version' for Adiak
+struct Version : public DataContainer<std::string, adiak::version> {
+  Version(const std::string &ver);
+
+  adiak::version to_adiak() const final;
+};
+
+// TODO replace use of string with std::filesystem if/when C++17 is supported
+// Python-compatible struct for storing path info
+// that will be converted into 'adiak::path' for Adiak
+struct Path : public DataContainer<std::string, adiak::path> {
+  Path(const std::string &p);
+
+  adiak::path to_adiak() const final;
+};
+
+// Python-compatible struct for storing categorical string info
+// that will be converted into 'adiak::catstring' for Adiak
+struct CatStr : public DataContainer<std::string, adiak::catstring> {
+  CatStr(const std::string &cs);
+
+  adiak::catstring to_adiak() const final;
+};
+
+// Python-compatible struct for storing JSON string info
+// that will be converted into 'adiak::jsonstring' for Adiak
+struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
+  JsonStr(const std::string &js);
+
+  adiak::jsonstring to_adiak() const final;
+};
+
 void create_adiak_annotation_mod(py::module_ &mod);
 
-}
+} // namespace python
 } // namespace adiak
 
 #endif /* ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_ */
diff --git a/src/interface/python/pyadiak_tool.cpp b/src/interface/python/pyadiak_tool.cpp
index bef7d0e..d02bd50 100644
--- a/src/interface/python/pyadiak_tool.cpp
+++ b/src/interface/python/pyadiak_tool.cpp
@@ -1,16 +1,182 @@
 #include "pyadiak_tool.hpp"
 #include "adiak_tool.h"
+#include "pyadiak.hpp"
+
+#include <chrono>
+#include <set>
+#include <stdexcept>
+#include <tuple>
+#include <vector>
 
 namespace adiak {
 namespace python {
 
+class PyadiakDataType {
+public:
+  PyadiakDataType() = default;
+
+  PyadiakDataType(adiak_datatype_t *c_type)
+      : m_adiak_dtype_ptr(c_type), m_dtype(c_type->dtype),
+        m_numerical(c_type->numerical), m_num_elems(c_type->num_elements),
+        m_num_subtypes(c_type->num_subtypes), m_subtypes(),
+        m_is_reference(c_type->is_reference == 0 ? false : true),
+        m_num_ref_elements(c_type->num_ref_elements) {
+    for (int i = 0; i < m_num_subtypes; i++) {
+      m_subtypes.push_back(PyadiakDataType(c_type->subtype[i]));
+    }
+  }
+
+  adiak_type_t get_dtype() const { return m_dtype; }
+
+  adiak_numerical_t get_numerical() const { return m_numerical; }
+
+  int get_num_elems() const {
+    if (m_is_reference) {
+      return m_num_ref_elements;
+    } else {
+      return m_num_elems;
+    }
+  }
+
+  int get_num_subtypes_in_container() const { return m_num_subtypes; }
+
+  bool is_reference() const { return m_is_reference; }
+
+  std::vector<PyadiakDataType> get_subtypes() const { return m_subtypes; }
+
+  adiak_datatype_t *get_adiak_dtype() { return m_adiak_dtype_ptr; }
+
+private:
+  adiak_datatype_t *m_adiak_dtype_ptr;
+  adiak_type_t m_dtype;
+  adiak_numerical_t m_numerical;
+  int m_num_elems;
+  int m_num_subtypes;
+  std::vector<PyadiakDataType> m_subtypes;
+  bool m_is_reference;
+  int m_num_ref_elements;
+};
+
+py::object convert_adiak_value_to_python(adiak_value_t *val,
+                                         adiak_datatype_t *type) {
+  // TODO import pyadiak module to get proper casting of data containers to
+  // py::object
+  switch (type->dtype) {
+  case adiak_long:
+    return py::cast<py::int_>(val->v_long);
+    break;
+  case adiak_ulong:
+    return py::cast<py::int_>((unsigned long)val->v_long);
+    break;
+  case adiak_int:
+    return py::cast<py::int_>(val->v_int);
+    break;
+  case adiak_uint:
+    return py::cast<py::int_>((unsigned int)val->v_int);
+    break;
+  case adiak_double:
+    return py::cast<py::float_>(val->v_double);
+  case adiak_date:
+    std::chrono::seconds chrono_seconds(val->v_long);
+    return py::cast(adiak::python::Date(
+        std::chrono::system_clock::time_point(chrono_seconds)));
+    break;
+  case adiak_timeval:
+    uint64_t num_microseconds = val->v_ptr->tv_sec * 1000000;
+    num_microseconds += val->v_ptr->tv_usec;
+    std::chrono::microseconds chrono_usec(num_microseconds);
+    return py::cast(adiak::python::Timepoint(
+        std::chrono::system_clock::time_point(chrono_usec)));
+    break;
+  case adiak_version:
+    return py::cast(adiak::python::Version(std::string(val->v_ptr)));
+    break;
+  case adiak_string:
+    return py::cast<py::str>(std::string(val->v_ptr));
+    break;
+  case adiak_catstring:
+    return py::cast(adiak::python::CatStr(std::string(val->v_ptr)));
+    break;
+  case adiak_jsonstring:
+    return py::cast(adiak::python::JsonStr(std::string(val->v_ptr)));
+    break;
+  case adiak_path:
+    return py::cast(adiak::python::Path(std::string(val->v_ptr)));
+    break;
+  case adiak_range:
+    if (type->num_subtypes != 2) {
+      throw std::runtime_error(
+          "Mismatch in Adiak between 'range' type and number of subtypes");
+    }
+    std::tuple<py::object, py::object> range_tuple = std::make_tuple(
+        convert_adiak_value_to_python(&(val->v_subval[0]), type->subtype[0]),
+        convert_adiak_value_to_python(&(val->v_subval[1]), type->subtype[1]));
+    return py::cast<py::tuple>(range_tuple);
+    break;
+  case adiak_set:
+    if (type->num_subtypes != 1) {
+      throw std::runtime_error(
+          "Mismatch in Adiak between 'set' type and number of subtypes");
+    }
+    adiak_datatype_t *subtype = type->subtype[0];
+    int num_elems =
+        type->is_reference != 0 ? type->num_ref_elements : type->num_elements;
+    std::set<py::object> set_val;
+    for (int i = 0; i < num_elems; i++) {
+      set_val.insert(
+          convert_adiak_value_to_python(&(val->v_subval[i]), subtype));
+    }
+    return py::cast<py::set>(set_val);
+    break;
+  case adiak_list:
+    if (type->num_subtypes != 1) {
+      throw std::runtime_error(
+          "Mismatch in Adiak between 'list' type and number of subtypes");
+    }
+    adiak_datatype_t *subtype = type->subtype[0];
+    int num_elems =
+        type->is_reference != 0 ? type->num_ref_elements : type->num_elements;
+    std::vector<py::object> list_val;
+    for (int i = 0; i < num_elems; i++) {
+      list_val.push_back(
+          convert_adiak_value_to_python(&(val->v_subval[i]), subtype));
+    }
+    return py::cast<py::list>(list_val);
+    break;
+  case adiak_tuple:
+    int num_subtypes = type->num_subtypes;
+    int num_elems =
+        type->is_reference != 0 ? type->num_ref_elements : type->num_elements;
+    if (num_subtypes != num_elems) {
+      throw std::runtime_error(
+          "Mismatch in Adiak between 'tuple' type and number of subtypes")
+    }
+    std::vector<py::object> list_val;
+    for (int i = 0; i < num_elems; i++) {
+      list_val.push_back(
+          convert_adiak_value_to_python(&(val->v_subval[i]), type->subtype[i]));
+    }
+    py::tuple tup_val = py::cast(list_val);
+    return tup_val;
+    break;
+  case adiak_longlong:
+    return py::cast<py::int_>(val->v_longlong);
+    break;
+  case adiak_ulonglong:
+    return py::cast<py::int_>(val->v_ulonglong);
+    break;
+  default:
+    throw std::runtime_error("Invalid datatype obtained from Adiak");
+  }
+}
+
 void pyadiak_tool_nameval_cb(const char *name, int category,
                              const char *subcategory, adiak_value_t *value,
                              adiak_datatype_t *t, void *py_cb) {
   py::handle nv_cb((PyObject *)py_cb);
-  // TODO add any necessary conversion from adiak_value_t and adiak_datatype_t
-  // to correct Python-compatible types
-  nv_cb(name, category, subcategory, value, t);
+  PyadiakDataType py_dtype(t);
+  py::object py_val = convert_adiak_value_to_python(value, t);
+  nv_cb(name, category, subcategory, py_val, py_dtype);
 }
 
 void pyadiak_register_cb(int adiak_version, int category, py::function nv_cb,
@@ -29,19 +195,77 @@ void pyadiak_list_namevals(int adiak_version, int category,
                       (void *)nv_cb_obj);
 }
 
-std::string pyadiak_type_to_string(adiak_datatype_t *t, bool long_form) {
-  // TODO implement once I figure out how to handle dtypes
-  return std::string("");
+std::string pyadiak_type_to_string(PyadiakDataType &type, bool long_form) {
+  adiak_datatype_t *adiak_dtype = type.get_adiak_dtype();
+  if (adiak_dtype == nullptr) {
+    throw std::runtime_error("Provided DataType is invalid");
+  }
+  char *alloced_str = adiak_type_to_string(adiak_dtype, long_form ? 1 : 0);
+  if (alloced_str == nullptr) {
+    throw std::runtime_error("Failed to get string for type");
+  }
+  std::string py_str(alloced_str);
+  free(alloced_str);
+  return py_str;
 }
 
-std::tuple<adiak_datatype_t *, adiak_value_t *, int, const char *>
+std::tuple<PyadiakDataType, py::object, int, const char *>
 pyadiak_get_nameval(const char *name) {
-  // TODO implement once I figure out how to handle dtypes and values
+  adiak_datatype_t *dtype = nullptr;
+  adiak_value_t *val = nullptr;
+  int category = 0;
+  const char *subcat = nullptr;
+  int rc = adiak_get_nameval(name, &dtype, &val, &category, &subcat);
+  if (rc != 0) {
+    throw std::runtime_error("Failed to get value for name");
+  }
+  py::object py_val = convert_adiak_value_to_python(val, dtype);
+  PyadiakDataType py_dtype(dtype);
+  return std::make_tuple(py_dtype, py_val, category, subcat);
 }
 
-int pyadiak_num_subvals(adiak_datatype_t *t) {
-  // TODO implement once I figure out how to handle dtypes
-  return 0;
+void create_adiak_tool_mod(py::module_ &mod) {
+  py::enum_<adiak_type_t>(mod, "AdiakTypeRaw")
+      .value("AdiakTypeUnset", adiak_type_unset)
+      .value("AdiakTypeLong", adiak_long)
+      .value("AdiakTypeULong", adiak_ulong)
+      .value("AdiakTypeInt", adiak_int)
+      .value("AdiakTypeUInt", adiak_uint)
+      .value("AdiakTypeDouble", adiak_double)
+      .value("AdiakTypeDate", adiak_date)
+      .value("AdiakTypeTimeval", adiak_timeval)
+      .value("AdiakTypeVersion", adiak_version)
+      .value("AdiakTypeString", adiak_string)
+      .value("AdiakTypeCatString", adiak_catstring)
+      .value("AdiakTypePath", adiak_path)
+      .value("AdiakTypeRange", adiak_range)
+      .value("AdiakTypeSet", adiak_set)
+      .value("AdiakTypeList", adiak_list)
+      .value("AdiakTypeTuple", adiak_tuple)
+      .value("AdiakTypeLongLong", adiak_longlong)
+      .value("AdiakTypeULongLong", adiak_ulonglong)
+      .value("AdiakTypeJsonString", adiak_jsonstring)
+      .export_values();
+  py::enum_<adiak_numerical_t>(mod, "AdiakNumerical")
+      .value("AdiakNumericalUnset", adiak_numerical_unset)
+      .value("AdiakNumericalCategorical", adiak_categorical)
+      .value("AdiakNumericalOrdinal", adiak_ordinal)
+      .value("AdiakNumericalInterval", adiak_interval)
+      .value("AdiakNumericalRational", adiak_rational)
+      .export_values();
+  py::class_<PyadiakDataType>(mod, "DataType")
+      .def(py::init<>())
+      .def("get_dtype", &PyadiakDataType::get_dtype)
+      .def("get_numerical", &PyadiakDataType::get_numerical)
+      .def("get_num_elems", &PyadiakDataType::get_num_elems)
+      .def("get_num_subtypes_in_container",
+           &PyadiakDataType::get_num_subtypes_in_container)
+      .def("is_reference", &PyadiakDataType::is_reference)
+      .def("get_subtypes", &PyadiakDataType::get_subtypes);
+  m.def("register_cb", &pyadiak_register_cb);
+  m.def("list_namevals", &pyadiak_list_namevals);
+  m.def("type_to_string", &pyadiak_type_to_string);
+  m.def("get_nameval", &pyadiak_get_nameval);
 }
 
 } // namespace python
diff --git a/src/interface/python/pyadiak_tool.hpp b/src/interface/python/pyadiak_tool.hpp
index 3b82d02..fc58eac 100644
--- a/src/interface/python/pyadiak_tool.hpp
+++ b/src/interface/python/pyadiak_tool.hpp
@@ -6,7 +6,7 @@
 namespace adiak {
 namespace python {
 
-void create_adiak_tool_annotation_mod(py::module_ &mod);
+void create_adiak_tool_mod(py::module_ &mod);
 
 }
 } // namespace adiak

From ce4405357b3d46191df9281bfa4dc08c69e27894 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Fri, 16 May 2025 11:32:45 -0400
Subject: [PATCH 04/22] Adds initial Python code for bindings

---
 src/interface/python/mod.cpp                | 4 ++--
 src/interface/python/pyadiak/__init__.py    | 0
 src/interface/python/pyadiak/annotations.py | 1 +
 src/interface/python/pyadiak/tools.py       | 1 +
 src/interface/python/pyadiak_tool.cpp       | 2 +-
 5 files changed, 5 insertions(+), 3 deletions(-)
 create mode 100644 src/interface/python/pyadiak/__init__.py
 create mode 100644 src/interface/python/pyadiak/annotations.py
 create mode 100644 src/interface/python/pyadiak/tools.py

diff --git a/src/interface/python/mod.cpp b/src/interface/python/mod.cpp
index aa4672c..d4be22d 100644
--- a/src/interface/python/mod.cpp
+++ b/src/interface/python/mod.cpp
@@ -5,9 +5,9 @@ PYBIND11_MODULE(__pyadiak_impl, m) {
   // TODO add version
 
   auto annotation_module =
-      m.def_submodule("annotation", "Submodule for annotation APIs");
+      m.def_submodule("annotations", "Submodule for annotation APIs");
   adiak::python::create_adiak_annotation_mod(annotation_module);
 
-  auto tool_module = m.def_submodule("tool", "Submodule for tool APIs");
+  auto tool_module = m.def_submodule("tools", "Submodule for tool APIs");
   adiak::python::create_adiak_tool_mod(tool_module);
 }
\ No newline at end of file
diff --git a/src/interface/python/pyadiak/__init__.py b/src/interface/python/pyadiak/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/interface/python/pyadiak/annotations.py b/src/interface/python/pyadiak/annotations.py
new file mode 100644
index 0000000..0285063
--- /dev/null
+++ b/src/interface/python/pyadiak/annotations.py
@@ -0,0 +1 @@
+from pyadiak.__pyadiak_impl.annotations import *
diff --git a/src/interface/python/pyadiak/tools.py b/src/interface/python/pyadiak/tools.py
new file mode 100644
index 0000000..6e7f32b
--- /dev/null
+++ b/src/interface/python/pyadiak/tools.py
@@ -0,0 +1 @@
+from pyadiak.__pyadiak_impl.tools import *
diff --git a/src/interface/python/pyadiak_tool.cpp b/src/interface/python/pyadiak_tool.cpp
index d02bd50..2cb00ee 100644
--- a/src/interface/python/pyadiak_tool.cpp
+++ b/src/interface/python/pyadiak_tool.cpp
@@ -59,7 +59,7 @@ class PyadiakDataType {
 
 py::object convert_adiak_value_to_python(adiak_value_t *val,
                                          adiak_datatype_t *type) {
-  // TODO import pyadiak module to get proper casting of data containers to
+  // TODO figure out if I need to do anything else to cast custom types to
   // py::object
   switch (type->dtype) {
   case adiak_long:

From 22ac407d75f1c6c76009c8550f89c39ea2a90c43 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Wed, 21 May 2025 12:59:05 -0700
Subject: [PATCH 05/22] Finishes implementation of Python bindings and adds
 build system support

---
 CMakeLists.txt                              |  18 +++
 src/CMakeLists.txt                          |   4 +
 src/interface/python/CMakeLists.txt         |  53 +++++++
 src/interface/python/mod.cpp                |   4 +
 src/interface/python/pyadiak.cpp            |  64 --------
 src/interface/python/pyadiak.hpp            |  93 +-----------
 src/interface/python/pyadiak/annotations.py | 108 +++++++++++++-
 src/interface/python/pyadiak/tools.py       | 156 +++++++++++++++++++-
 src/interface/python/pyadiak/types.py       |  26 ++++
 src/interface/python/pyadiak_tool.cpp       |   4 +-
 src/interface/python/types.cpp              |  79 ++++++++++
 src/interface/python/types.hpp              | 105 +++++++++++++
 12 files changed, 554 insertions(+), 160 deletions(-)
 create mode 100644 src/interface/python/CMakeLists.txt
 create mode 100644 src/interface/python/pyadiak/types.py
 create mode 100644 src/interface/python/types.cpp
 create mode 100644 src/interface/python/types.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 841367c..22146de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,6 +9,11 @@ if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
   set(CMAKE_INSTALL_LIBDIR lib)
 endif()
 
+# Find Python by location
+if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.15)
+  cmake_policy(SET CMP0094 NEW)
+endif()
+
 set(BLT_EXPORT_THIRDPARTY ON CACHE BOOL "")
 
 if (DEFINED BLT_SOURCE_DIR)
@@ -31,6 +36,19 @@ endif()
 
 include(${BLT_SOURCE_DIR}/SetupBLT.cmake)
 
+option(WITH_PYTHON_BINDINGS "Build/Install Python bindings for Adiak" FALSE)
+
+if (WITH_PYTHON_BINDINGS)
+  find_package(Python COMPONENTS Interpreter Development REQUIRED)
+  find_package(pybind11 CONFIG REQUIRED)
+  
+  if (pybind11_FOUND)
+    set(ADIAK_HAVE_PYBIND11 TRUE)
+  else()
+    message(WARNING "Python bindings requested, but pybind11 not found")
+  endif()
+endif()
+
 add_subdirectory(src)
 if (ENABLE_TESTS)
   add_subdirectory(tests)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 6266aa2..f4f9988 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -53,3 +53,7 @@ install(TARGETS
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 install(EXPORT adiak-targets NAMESPACE adiak:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adiak)
+
+if (WITH_PYTHON_BINDINGS)
+  add_subdirectory(interface/python)
+endif()
diff --git a/src/interface/python/CMakeLists.txt b/src/interface/python/CMakeLists.txt
new file mode 100644
index 0000000..59c3f58
--- /dev/null
+++ b/src/interface/python/CMakeLists.txt
@@ -0,0 +1,53 @@
+set(PYADIAK_BINDING_SOURCES
+    mod.cpp
+    pyadiak_tool.cpp
+    pyadiak.cpp
+    types.cpp
+)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+
+set(PYADIAK_SYSCONFIG_SCHEME "posix_user" CACHE STRING "Scheme used for searching for pyadiak's install path. Valid options can be determined with 'sysconfig.get_scheme_names()'")
+
+execute_process(
+  COMMAND
+    ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/cmake/get_python_install_paths.py purelib ${PYADIAK_SYSCONFIG_SCHEME}
+  OUTPUT_VARIABLE
+    PYADIAK_SITELIB)
+execute_process(
+  COMMAND
+    ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/cmake/get_python_install_paths.py platlib ${PYADIAK_SYSCONFIG_SCHEME}
+  OUTPUT_VARIABLE
+    PYADIAK_SITEARCH)
+
+set(PYADIAK_SITELIB "${PYADIAK_SITELIB}/pyadiak")
+set(PYADIAK_SITEARCH "${PYADIAK_SITEARCH}/pyadiak")
+
+pybind11_add_module(__pyadiak_impl ${PYADIAK_BINDING_SOURCES})
+target_link_libraries(__pyadiak_impl PUBLIC adiak)
+target_compile_features(__pyadiak_impl PUBLIC cxx_std_11)
+target_include_directories(__pyadiak_impl PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
+add_custom_target(
+    pyadiak_py_source_copy ALL # Always build pycaliper_test
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/pyadiak
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/pyadiak ${CMAKE_CURRENT_BINARY_DIR}/pyadiak
+    COMMENT "Copying pyadiak Python source to ${CMAKE_CURRENT_BINARY_DIR}/pyadiak"
+)
+add_dependencies(__pyadiak_impl pyadiak_py_source_copy)
+
+install(
+    DIRECTORY
+        pyadiak/
+    DESTINATION
+        ${PYADIAK_SITELIB}
+)
+
+install(
+    TARGETS
+        __pyadiak_impl
+    ARCHIVE DESTINATION
+        ${PYADIAK_SITEARCH}
+    LIBRARY DESTINATION
+        ${PYADIAK_SITEARCH}
+)
diff --git a/src/interface/python/mod.cpp b/src/interface/python/mod.cpp
index d4be22d..9408140 100644
--- a/src/interface/python/mod.cpp
+++ b/src/interface/python/mod.cpp
@@ -4,6 +4,10 @@
 PYBIND11_MODULE(__pyadiak_impl, m) {
   // TODO add version
 
+  auto types_module =
+      m.def_submodule("types", "Submodule for type wrappers in Adiak");
+  adiak::python::create_adiak_types_mod(types_module);
+
   auto annotation_module =
       m.def_submodule("annotations", "Submodule for annotation APIs");
   adiak::python::create_adiak_annotation_mod(annotation_module);
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index fb9ab71..ecd6e52 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -57,48 +57,6 @@ template <> struct type_caster<mpi4py_comm> {
 namespace adiak {
 namespace python {
 
-Timepoint::Timepoint(std::chrono::system_clock::time_point time)
-    : DataContainer<std::chrono::system_clock::time_point, struct timeval *>(
-          time) {}
-
-struct timeval *Timepoint::to_adiak() const {
-  auto time_since_epoch = std::chrono::duration_cast<std::chrono::microseconds>(
-      m_v.time_since_epoch());
-  m_time_for_adiak.tv_sec = time_since_epoch.count() / 1000000;
-  m_time_for_adiak.tv_usec = time_since_epoch.count() % 1000000;
-  return &m_time_for_adiak;
-}
-
-Date::Date(std::chrono::system_clock::time_point time)
-    : DataContainer<std::chrono::system_clock::time_point, adiak::date>(time) {}
-
-adiak::date Date::to_adiak() const {
-  auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
-      value.time_since_epoch());
-  return adiak::date(time_since_epoch.count());
-}
-
-Version::Version(const std::string &ver)
-    : DataContainer<std::string, adiak::version>(ver) {}
-
-adiak::version Version::to_adiak() const { return adiak::version(m_v); }
-
-Path::Path(const std::string &p) : DataContainer<std::string, adiak::path>(p) {}
-
-adiak::path Path::to_adiak() const { return adiak::path(m_v); }
-
-CatStr::CatStr(const std::string &cs)
-    : DataContainer<std::string, adiak::catstring>(cs) {}
-
-adiak::catstringCatStr::to_adiak() const { return adiak::catstring(m_v); }
-
-CatStr::to_adiak() const { return adiak::catstring(m_v); }
-
-JsonStr::JsonStr(const std::string &js)
-    : DataContainer<std::string, adiak::jsonstring>(js) {}
-
-adiak::jsonstring JsonStr::to_adiak() const { return adiak::jsonstring(m_v); }
-
 // Custom wrapper for adiak::init
 // The only difference is that it uses the behavior of the pybind11
 // type_caster above to decide whether to pass an MPI communicator
@@ -159,28 +117,6 @@ void create_adiak_annotation_mod(py::module_ &mod) {
         "Cannot load mpi4py within the Adiak Python bindings");
   }
 
-  // Bind the custom data containers to Python.
-  // Note that we don't wrap the DataContainer base class or the 'to_adiak'
-  // methods because we don't need those exposed to Python.
-  py::class_<adiak::python::Timepoint>(mod, "Timepoint")
-      .def(py::init<std::chrono::system_clock::time_point>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-  py::class_<adiak::python::Date>(mod, "Date")
-      .def(py::init<std::chrono::system_clock::time_point>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-  py::class_<adiak::python::Version>(mod, "Version")
-      .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-  py::class_<adiak::python::Path>(mod, "Path")
-      .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-  py::class_<adiak::python::CatStr>(mod, "CatStr")
-      .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-  py::class_<adiak::python::JsonStr>(mod, "JsonStr")
-      .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
-
   // Bind 'init' and 'fini'
   mod.def("init", &adiak::python::init);
   mod.def("fini", GENERATE_API_CALL_NO_ARGS(fini));
diff --git a/src/interface/python/pyadiak.hpp b/src/interface/python/pyadiak.hpp
index c628113..de866dd 100644
--- a/src/interface/python/pyadiak.hpp
+++ b/src/interface/python/pyadiak.hpp
@@ -1,102 +1,11 @@
 #ifndef ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
 #define ADIAK_INTERFACE_PYTHON_PYADIAK_HPP_
 
-#include "common.hpp"
-
-#include <chrono>
-#include <type_traits>
+#include "types.hpp"
 
 namespace adiak {
 namespace python {
 
-// The 'is_templated_base_of' type trait is derived from the following
-// StackOverflow post:
-// https://stackoverflow.com/a/49163138
-template <template <typename...> class Base, typename Derived,
-          typename TCheck = void>
-struct is_templated_base_of_tester;
-
-template <template <typename...> class Base, typename Derived>
-struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
-  template <typename... T> static constexpr std::true_type test(Base<T...> *);
-  static constexpr std::false_type test(...);
-  using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
-};
-
-template <template <typename...> class Base, typename Derived>
-struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
-  using is_base = std::false_type;
-};
-
-template <template <typename...> class Base, typename Derived>
-using is_templated_base_of =
-    typename is_templated_base_of_tester<Base, Derived>::is_base;
-
-template <typename T, class adiak_type> struct DataContainer {
-  T m_v;
-
-  DataContainer(T val) : m_v(val) {}
-
-  virtual T to_python() const { return m_v; }
-
-  virtual adiak_type to_adiak() const = 0;
-};
-
-// Python-compatible struct for storing timepoint info
-// that will be converted into 'struct timeval' for Adiak
-struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
-                                        struct timeval *> {
-  struct timeval m_time_for_adiak;
-
-  Timepoint(std::chrono::system_clock::time_point time);
-
-  struct timeval *to_adiak() const final;
-};
-
-// Python-compatible struct for storing date or datetime info
-// that will be converted into 'adiak::date' for Adiak
-struct Date
-    : public DataContainer<std::chrono::system_clock::time_point, adiak::date> {
-  Date(std::chrono::system_clock::time_point time);
-
-  adiak::date to_adiak() const final;
-};
-
-// Python-compatible struct for storing version info
-// that will be converted into 'adiak::version' for Adiak
-struct Version : public DataContainer<std::string, adiak::version> {
-  Version(const std::string &ver);
-
-  adiak::version to_adiak() const final;
-};
-
-// TODO replace use of string with std::filesystem if/when C++17 is supported
-// Python-compatible struct for storing path info
-// that will be converted into 'adiak::path' for Adiak
-struct Path : public DataContainer<std::string, adiak::path> {
-  Path(const std::string &p);
-
-  adiak::path to_adiak() const final;
-};
-
-// Python-compatible struct for storing categorical string info
-// that will be converted into 'adiak::catstring' for Adiak
-struct CatStr : public DataContainer<std::string, adiak::catstring> {
-  CatStr(const std::string &cs);
-
-  adiak::catstring to_adiak() const final;
-};
-
-// Python-compatible struct for storing JSON string info
-// that will be converted into 'adiak::jsonstring' for Adiak
-struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
-  JsonStr(const std::string &js);
-
-  adiak::jsonstring to_adiak() const final;
-};
-
 void create_adiak_annotation_mod(py::module_ &mod);
 
 } // namespace python
diff --git a/src/interface/python/pyadiak/annotations.py b/src/interface/python/pyadiak/annotations.py
index 0285063..4cc5046 100644
--- a/src/interface/python/pyadiak/annotations.py
+++ b/src/interface/python/pyadiak/annotations.py
@@ -1 +1,107 @@
-from pyadiak.__pyadiak_impl.annotations import *
+from datetime import date, datetime, time
+from pathlib import Path as PyPath
+from typing import Any
+from warnings import warn
+
+from pyadiak.__pyadiak_impl.annotations import (
+    adiakversion,
+    clean,
+    clustername,
+    cmdline,
+    collect_all,
+    cputime,
+    executable,
+    executablepath,
+    fini,
+    flush,
+    hostlist,
+    hostname,
+    jobsize,
+    launchdate,
+    launchday,
+    libraries,
+    mpi_library,
+    mpi_library_version,
+    mpi_version,
+    numhosts,
+    systime,
+    uid,
+    user,
+    walltime,
+    workdir,
+)
+from pyadiak.__pyadiak_impl.annotations import (
+    init as cpp_init,
+)
+from pyadiak.__pyadiak_impl.annotations import (
+    value as cpp_value,
+)
+from pyadiak.types import *
+
+
+def init(comm=None):
+    try:
+        from mpi4py.MPI import Comm
+
+        if comm is not None and not isinstance(comm, Comm):
+            raise TypeError(
+                "The 'comm' argument to 'init' must be of type mpi4py.MPI.Comm"
+            )
+        cpp_init(comm)
+    except ImportError:
+        if comm is not None:
+            warn(
+                "A value was passed to the 'comm' argument, but there is no way for it to be the correct type because mpi4py cannot be imported. If you want to pass an MPI communicator, install mpi4py first.",
+                RuntimeWarning,
+            )
+        cpp_init(None)
+
+
+def value(name: str, value: Any, category=Category.General, subcategory="") -> bool:
+    wrapped_value = value
+    if isinstance(value, date):
+        wrapped_value = Date(value)
+    elif isinstance(value, (time, datetime)):
+        wrapped_value = Timepoint(value)
+    elif isinstance(value, PyPath):
+        wrapped_value = Path(value)
+    if not isinstance(category, Category):
+        raise TypeError(
+            f"Invalid type ('{type(category)}') for 'category' parameter. Should be 'Category'"
+        )
+    if not isinstance(subcategory, str):
+        raise TypeError(
+            f"Invalid type ('{type(subcategory)}') for 'subcategory' parameter. Should be 'str'"
+        )
+    return cpp_value(name, wrapped_value, int(category), subcategory)
+
+
+__all__ = [
+    "init",
+    "fini",
+    "value",
+    "adiakversion",
+    "user",
+    "uid",
+    "launchdate",
+    "launchday",
+    "executable",
+    "executablepath",
+    "workdir",
+    "libraries",
+    "cmdline",
+    "hostname",
+    "clustername",
+    "walltime",
+    "systime",
+    "cputime",
+    "jobsize",
+    "hostlist",
+    "numhosts",
+    "mpi_version",
+    "mpi_library",
+    "mpi_library_version",
+    "flush",
+    "clean",
+    "collect_all",
+]
diff --git a/src/interface/python/pyadiak/tools.py b/src/interface/python/pyadiak/tools.py
index 6e7f32b..38f1029 100644
--- a/src/interface/python/pyadiak/tools.py
+++ b/src/interface/python/pyadiak/tools.py
@@ -1 +1,155 @@
-from pyadiak.__pyadiak_impl.tools import *
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Any, Callable, List, Tuple
+
+from pyadiak.__pyadiak_impl.tools import (
+    AdiakDataType,
+    AdiakNumerical,
+    AdiakTypeRaw,
+)
+from pyadiak.__pyadiak_impl.tools import (
+    get_nameval as cpp_get_nameval,
+)
+from pyadiak.__pyadiak_impl.tools import (
+    list_namevals as cpp_list_namevals,
+)
+from pyadiak.__pyadiak_impl.tools import (
+    register_cb as cpp_register_cb,
+)
+from pyadiak.__pyadiak_impl.tools import (
+    type_to_string as cpp_type_to_string,
+)
+from pyadiak.types import Category
+
+
+class Type(IntEnum):
+    Unset = AdiakTypeRaw.AdiakTypeUnset
+    Long = AdiakTypeRaw.AdiakTypeLong
+    ULong = AdiakTypeRaw.AdiakTypeULong
+    Int = AdiakTypeRaw.AdiakTypeInt
+    UInt = AdiakTypeRaw.AdiakTypeUInt
+    Double = AdiakTypeRaw.AdiakTypeDouble
+    Date = AdiakTypeRaw.AdiakTypeDate
+    Timeval = AdiakTypeRaw.AdiakTypeTimeval
+    Version = AdiakTypeRaw.AdiakTypeVersion
+    String = AdiakTypeRaw.AdiakTypeString
+    CatString = AdiakTypeRaw.AdiakTypeCatString
+    Path = AdiakTypeRaw.AdiakTypePath
+    Range = AdiakTypeRaw.AdiakTypeRange
+    Set = AdiakTypeRaw.AdiakTypeSet
+    List = AdiakTypeRaw.AdiakTypeList
+    Tuple = AdiakTypeRaw.AdiakTypeTuple
+    LongLong = AdiakTypeRaw.AdiakTypeLongLong
+    ULongLong = AdiakTypeRaw.AdiakTypeULongLong
+    JsonString = AdiakTypeRaw.AdiakTypeJsonString
+
+    @staticmethod
+    def from_cpp_type(v: AdiakTypeRaw) -> Type:
+        return Type(int(v))
+
+
+class Numerical(IntEnum):
+    Unset = AdiakNumerical.AdiakNumericalUnset
+    Categorical = AdiakNumerical.AdiakNumericalCategorical
+    Ordinal = AdiakNumerical.AdiakNumericalOrdinal
+    Interval = AdiakNumerical.AdiakNumericalInterval
+    Rational = AdiakNumerical.AdiakNumericalRational
+
+    @staticmethod
+    def from_cpp_numerical(v: AdiakNumerical) -> Numerical:
+        return Numerical(int(v))
+
+
+class DataType:
+    def __init__(self, raw_datatype: AdiakDataType):
+        self.dtype = raw_datatype
+
+    def get_dtype(self) -> Type:
+        cpp_type = self.dtype.get_dtype()
+        return Type.from_cpp_type(cpp_type)
+
+    def get_numerical(self) -> Numerical:
+        cpp_num = self.dtype.get_numerical()
+        return Numerical.from_cpp_numerical(cpp_num)
+
+    def get_num_elems(self) -> int:
+        return self.dtype.get_num_elems()
+
+    def get_num_subtypes_in_container(self) -> int:
+        return self.dtype.get_num_subtypes_in_container()
+
+    def is_reference(self) -> bool:
+        return self.dtype.is_reference()
+
+    def get_subtypes(self) -> List[DataType]:
+        cpp_types = self.get_subtypes()
+        return [DataType(ct) for ct in cpp_types]
+
+
+AdiakToolCallback = Callable[str, Category, str, Any, DataType]
+
+
+def __wrap_cb_in_caster_func(cb: AdiakToolCallback) -> Callable:
+    def __wrapper_func(
+        name: str, cat: int, subcat: str, val: Any, dtype: AdiakDataType
+    ):
+        local_category = Category(cat)
+        local_dtype = DataType(dtype)
+        cb(str, local_category, subcat, val, local_dtype)
+
+    return __wrapper_func
+
+
+def register_cb(
+    adiak_version: int,
+    cat: Category,
+    callback: AdiakToolCallback,
+    report_on_all_ranks: bool,
+):
+    if not isinstance(adiak_version, int):
+        raise TypeError("The 'adiak_version' parameter must be an int")
+    if not isinstance(cat, Category):
+        raise TypeError("The 'cat' parameter must be a 'pyadiak.types.Category'")
+    if not isinstance(callback, AdiakToolCallback):
+        raise TypeError(
+            "The 'callback' parameter must be a 'pyadiak.tools.AdiakToolCallback'"
+        )
+    wrapped_cb = __wrap_cb_in_caster_func(callback)
+    cpp_register_cb(adiak_version, int(cat), wrapped_cb, report_on_all_ranks)
+
+
+def list_namevals(adiak_version: int, cat: Category, callback: AdiakToolCallback):
+    if not isinstance(adiak_version, int):
+        raise TypeError("The 'adiak_version' parameter must be an int")
+    if not isinstance(cat, Category):
+        raise TypeError("The 'cat' parameter must be a 'pyadiak.types.Category'")
+    if not isinstance(callback, AdiakToolCallback):
+        raise TypeError(
+            "The 'callback' parameter must be a 'pyadiak.tools.AdiakToolCallback'"
+        )
+    wrapped_cb = __wrap_cb_in_caster_func(callback)
+    cpp_list_namevals(adiak_version, int(cat), wrapped_cb)
+
+
+def type_to_string(dtype: DataType, long_form=False) -> str:
+    if not isinstance(dtype, DataType):
+        raise TypeError("The 'dtype' parameter must be a 'pyadiak.tools.DataType'")
+    return cpp_type_to_string(dtype.dtype, long_form)
+
+
+def get_nameval(name: str) -> Tuple[DataType, Any, Category, str]:
+    cpp_tup = cpp_get_nameval(name)
+    return (DataType(cpp_tup[0]), cpp_tup[1], Category(cpp_tup[2]), cpp_tup[3])
+
+
+__all__ = [
+    "Type",
+    "Numerical",
+    "DataType",
+    "AdiakToolCallback",
+    "register_cb",
+    "list_namevals",
+    "type_to_string",
+    "get_nameval",
+]
diff --git a/src/interface/python/pyadiak/types.py b/src/interface/python/pyadiak/types.py
new file mode 100644
index 0000000..2525ca0
--- /dev/null
+++ b/src/interface/python/pyadiak/types.py
@@ -0,0 +1,26 @@
+from enum import IntEnum
+
+from pyadiak.__pyadiak_impl.types import (
+    ADIAK_CATEGORY_ALL,
+    ADIAK_CATEGORY_CONTROL,
+    ADIAK_CATEGORY_GENERAL,
+    ADIAK_CATEGORY_PERFORMANCE,
+    ADIAK_CATEGORY_UNSET,
+    CatStr,
+    Date,
+    JsonStr,
+    Path,
+    Timepoint,
+    Version,
+)
+
+
+class Category(IntEnum):
+    Unset = ADIAK_CATEGORY_UNSET
+    All = ADIAK_CATEGORY_ALL
+    General = ADIAK_CATEGORY_GENERAL
+    Performance = ADIAK_CATEGORY_PERFORMANCE
+    Control = ADIAK_CATEGORY_CONTROL
+
+
+__all__ = ["CatStr", "Date", "JsonStr", "Path", "Timepoint", "Version", "Category"]
diff --git a/src/interface/python/pyadiak_tool.cpp b/src/interface/python/pyadiak_tool.cpp
index 2cb00ee..ce9f211 100644
--- a/src/interface/python/pyadiak_tool.cpp
+++ b/src/interface/python/pyadiak_tool.cpp
@@ -1,6 +1,6 @@
 #include "pyadiak_tool.hpp"
 #include "adiak_tool.h"
-#include "pyadiak.hpp"
+#include "types.hpp"
 
 #include <chrono>
 #include <set>
@@ -253,7 +253,7 @@ void create_adiak_tool_mod(py::module_ &mod) {
       .value("AdiakNumericalInterval", adiak_interval)
       .value("AdiakNumericalRational", adiak_rational)
       .export_values();
-  py::class_<PyadiakDataType>(mod, "DataType")
+  py::class_<PyadiakDataType>(mod, "AdiakDataType")
       .def(py::init<>())
       .def("get_dtype", &PyadiakDataType::get_dtype)
       .def("get_numerical", &PyadiakDataType::get_numerical)
diff --git a/src/interface/python/types.cpp b/src/interface/python/types.cpp
new file mode 100644
index 0000000..b0db196
--- /dev/null
+++ b/src/interface/python/types.cpp
@@ -0,0 +1,79 @@
+#include "types.hpp"
+#include "adiak.hpp"
+
+namespace adiak {
+namespace python {
+
+Timepoint::Timepoint(std::chrono::system_clock::time_point time)
+    : DataContainer<std::chrono::system_clock::time_point, struct timeval *>(
+          time) {}
+
+struct timeval *Timepoint::to_adiak() const {
+  auto time_since_epoch = std::chrono::duration_cast<std::chrono::microseconds>(
+      m_v.time_since_epoch());
+  m_time_for_adiak.tv_sec = time_since_epoch.count() / 1000000;
+  m_time_for_adiak.tv_usec = time_since_epoch.count() % 1000000;
+  return &m_time_for_adiak;
+}
+
+Date::Date(std::chrono::system_clock::time_point time)
+    : DataContainer<std::chrono::system_clock::time_point, adiak::date>(time) {}
+
+adiak::date Date::to_adiak() const {
+  auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
+      value.time_since_epoch());
+  return adiak::date(time_since_epoch.count());
+}
+
+Version::Version(const std::string &ver)
+    : DataContainer<std::string, adiak::version>(ver) {}
+
+adiak::version Version::to_adiak() const { return adiak::version(m_v); }
+
+Path::Path(const std::string &p) : DataContainer<std::string, adiak::path>(p) {}
+
+adiak::path Path::to_adiak() const { return adiak::path(m_v); }
+
+CatStr::CatStr(const std::string &cs)
+    : DataContainer<std::string, adiak::catstring>(cs) {}
+
+adiak::catstringCatStr::to_adiak() const { return adiak::catstring(m_v); }
+
+CatStr::to_adiak() const { return adiak::catstring(m_v); }
+
+JsonStr::JsonStr(const std::string &js)
+    : DataContainer<std::string, adiak::jsonstring>(js) {}
+
+adiak::jsonstring JsonStr::to_adiak() const { return adiak::jsonstring(m_v); }
+
+void create_adiak_types_mod(py::module_ &mod) {
+  mod.attr("ADIAK_CATEGORY_UNSET") = py::int_(adiak_category_unset);
+  mod.attr("ADIAK_CATEGORY_ALL") = py::int_(adiak_category_all);
+  mod.attr("ADIAK_CATEGORY_GENERAL") = py::int_(adiak_general);
+  mod.attr("ADIAK_CATEGORY_PERFORMANCE") = py::int_(adiak_performance);
+  mod.attr("ADIAK_CATEGORY_CONTROL") = py::int_(adiak_control);
+  // Bind the custom data containers to Python.
+  // Note that we don't wrap the DataContainer base class or the 'to_adiak'
+  // methods because we don't need those exposed to Python.
+  py::class_<adiak::python::Timepoint>(mod, "Timepoint")
+      .def(py::init<std::chrono::system_clock::time_point>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+  py::class_<adiak::python::Date>(mod, "Date")
+      .def(py::init<std::chrono::system_clock::time_point>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+  py::class_<adiak::python::Version>(mod, "Version")
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+  py::class_<adiak::python::Path>(mod, "Path")
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+  py::class_<adiak::python::CatStr>(mod, "CatStr")
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+  py::class_<adiak::python::JsonStr>(mod, "JsonStr")
+      .def(py::init<const std::string &>())
+      .def("to_python", &adiak::python::Timepoint::to_python);
+}
+
+} // namespace python
+} // namespace adiak
\ No newline at end of file
diff --git a/src/interface/python/types.hpp b/src/interface/python/types.hpp
new file mode 100644
index 0000000..28fbce3
--- /dev/null
+++ b/src/interface/python/types.hpp
@@ -0,0 +1,105 @@
+#ifndef ADIAK_INTERFACE_PYTHON_TYPES_HPP_
+#define ADIAK_INTERFACE_PYTHON_TYPES_HPP_
+
+#include "common.hpp"
+
+#include <chrono>
+#include <type_traits>
+
+namespace adiak {
+namespace python {
+
+// The 'is_templated_base_of' type trait is derived from the following
+// StackOverflow post:
+// https://stackoverflow.com/a/49163138
+template <template <typename...> class Base, typename Derived,
+          typename TCheck = void>
+struct is_templated_base_of_tester;
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
+  template <typename... T> static constexpr std::true_type test(Base<T...> *);
+  static constexpr std::false_type test(...);
+  using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
+};
+
+template <template <typename...> class Base, typename Derived>
+struct is_templated_base_of_tester<
+    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
+  using is_base = std::false_type;
+};
+
+template <template <typename...> class Base, typename Derived>
+using is_templated_base_of =
+    typename is_templated_base_of_tester<Base, Derived>::is_base;
+
+template <typename T, class adiak_type> struct DataContainer {
+  T m_v;
+
+  DataContainer(T val) : m_v(val) {}
+
+  virtual T to_python() const { return m_v; }
+
+  virtual adiak_type to_adiak() const = 0;
+};
+
+// Python-compatible struct for storing timepoint info
+// that will be converted into 'struct timeval' for Adiak
+struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
+                                        struct timeval *> {
+  struct timeval m_time_for_adiak;
+
+  Timepoint(std::chrono::system_clock::time_point time);
+
+  struct timeval *to_adiak() const final;
+};
+
+// Python-compatible struct for storing date or datetime info
+// that will be converted into 'adiak::date' for Adiak
+struct Date
+    : public DataContainer<std::chrono::system_clock::time_point, adiak::date> {
+  Date(std::chrono::system_clock::time_point time);
+
+  adiak::date to_adiak() const final;
+};
+
+// Python-compatible struct for storing version info
+// that will be converted into 'adiak::version' for Adiak
+struct Version : public DataContainer<std::string, adiak::version> {
+  Version(const std::string &ver);
+
+  adiak::version to_adiak() const final;
+};
+
+// TODO replace use of string with std::filesystem if/when C++17 is supported
+// Python-compatible struct for storing path info
+// that will be converted into 'adiak::path' for Adiak
+struct Path : public DataContainer<std::string, adiak::path> {
+  Path(const std::string &p);
+
+  adiak::path to_adiak() const final;
+};
+
+// Python-compatible struct for storing categorical string info
+// that will be converted into 'adiak::catstring' for Adiak
+struct CatStr : public DataContainer<std::string, adiak::catstring> {
+  CatStr(const std::string &cs);
+
+  adiak::catstring to_adiak() const final;
+};
+
+// Python-compatible struct for storing JSON string info
+// that will be converted into 'adiak::jsonstring' for Adiak
+struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
+  JsonStr(const std::string &js);
+
+  adiak::jsonstring to_adiak() const final;
+};
+
+void create_adiak_types_mod(py::module_ &mod);
+
+} // namespace python
+} // namespace adiak
+
+#endif /* ADIAK_INTERFACE_PYTHON_TYPES_HPP_ */
\ No newline at end of file

From 82dccffca9af461a42a3af667f08c48ce4a60cb7 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Wed, 21 May 2025 12:59:26 -0700
Subject: [PATCH 06/22] Updates GitHub Action to test build of Python bindings

---
 .github/workflows/cmake.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index ff83e34..065dd4f 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -42,6 +42,10 @@ jobs:
       uses: actions/checkout@v2
       with:
         submodules: recursive
+          
+    - name: Install Python binding dependencies
+      run: |
+        python3 -m pip install pybind11 mpi4py
 
     - name: Create Build Environment
       # Some projects don't allow in-source building, so create a separate build directory
@@ -56,7 +60,7 @@ jobs:
       # Note the current convention is to use the -S and -B options here to specify source 
       # and build directories, but this is only available with CMake 3.13 and higher.  
       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}}
+      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DWITH_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir)
 
     - name: Build
       working-directory: ${{github.workspace}}/build

From f2f90bb2dd1dced8f7f3254ca48961dac4951296 Mon Sep 17 00:00:00 2001
From: Ian Lumsden <lumsden.ian@gmail.com>
Date: Thu, 22 May 2025 11:38:27 -0700
Subject: [PATCH 07/22] Updates the CMake Action to properly install Python and
 MPI

---
 .github/workflows/cmake.yml | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 065dd4f..67f28e3 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -25,23 +25,36 @@ jobs:
           - {
               name: "Ubuntu Latest GCC",
               os: ubuntu-latest,
-              build_type: "Release", cc: "gcc", cxx: "g++"
+              build_type: "Release", cc: "gcc", cxx: "g++",
+              mpi_type: "mpich"
             }
           - {
               name: "Ubuntu Latest Clang",
               os: ubuntu-latest,
-              build_type: "Release", cc: "clang", cxx: "clang++"
+              build_type: "Release", cc: "clang", cxx: "clang++",
+              mpi_type: "mpich"
             }
           - {
               name: "macOS Latest Clang",
               os: macos-latest,
-              build_type: "Release", cc: "clang", cxx: "clang++"
+              build_type: "Release", cc: "clang", cxx: "clang++",
+              mpi_type: "mpich"
             }
     steps:
     - name: Checkout repository and submodules
       uses: actions/checkout@v2
       with:
         submodules: recursive
+
+    - name: Install Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.13'
+
+    - name: Install MPI
+      uses: mpi4py/setup-mpi@v1.3.2
+      with:
+        mpi: ${{matrix.config.mpi_type}}
           
     - name: Install Python binding dependencies
       run: |

From db71b96dd16c4bbcf4d9e4f5ba172a273ec5b51e Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Tue, 29 Jul 2025 12:45:19 -0700
Subject: [PATCH 08/22] Add missing file for python install paths

---
 cmake/get_python_install_paths.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 cmake/get_python_install_paths.py

diff --git a/cmake/get_python_install_paths.py b/cmake/get_python_install_paths.py
new file mode 100644
index 0000000..eb48232
--- /dev/null
+++ b/cmake/get_python_install_paths.py
@@ -0,0 +1,14 @@
+import sys
+import sysconfig
+
+if len(sys.argv) != 3 or sys.argv[1] not in ("purelib", "platlib"):
+    raise RuntimeError(
+        "Usage: python get_python_install_paths.py <purelib | platlib> <sysconfig_scheme>"
+    )
+
+install_dir = sysconfig.get_path(sys.argv[1], sys.argv[2], {"userbase": "", "base": ""})
+
+if install_dir.startswith("/"):
+    install_dir = install_dir[1:]
+
+print(install_dir, end="")

From 6f4d47e81e09bb87c5ebc26e5434bf7f297eb0e1 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Tue, 29 Jul 2025 12:45:54 -0700
Subject: [PATCH 09/22] Fix build errors & runtime errors

---
 src/interface/python/CMakeLists.txt         |   6 +
 src/interface/python/common.hpp             |   3 +
 src/interface/python/pyadiak.cpp            | 161 ++++++++++++++------
 src/interface/python/pyadiak/annotations.py |   3 +-
 src/interface/python/pyadiak_tool.cpp       |  62 ++++----
 src/interface/python/types.cpp              |  16 +-
 src/interface/python/types.hpp              |  43 +++++-
 7 files changed, 205 insertions(+), 89 deletions(-)

diff --git a/src/interface/python/CMakeLists.txt b/src/interface/python/CMakeLists.txt
index 59c3f58..5c44765 100644
--- a/src/interface/python/CMakeLists.txt
+++ b/src/interface/python/CMakeLists.txt
@@ -27,6 +27,12 @@ pybind11_add_module(__pyadiak_impl ${PYADIAK_BINDING_SOURCES})
 target_link_libraries(__pyadiak_impl PUBLIC adiak)
 target_compile_features(__pyadiak_impl PUBLIC cxx_std_11)
 target_include_directories(__pyadiak_impl PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+execute_process(
+  COMMAND python3 -c "import mpi4py, os; print(os.path.join(os.path.dirname(mpi4py.__file__), 'include'))"
+  OUTPUT_VARIABLE MPI4PY_INCLUDE_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+include_directories(${MPI4PY_INCLUDE_DIR})
 
 add_custom_target(
     pyadiak_py_source_copy ALL # Always build pycaliper_test
diff --git a/src/interface/python/common.hpp b/src/interface/python/common.hpp
index 4103d65..2704271 100644
--- a/src/interface/python/common.hpp
+++ b/src/interface/python/common.hpp
@@ -1,6 +1,9 @@
 #ifndef ADIAK_INTERFACE_PYTHON_COMMON_HPP_
 #define ADIAK_INTERFACE_PYTHON_COMMON_HPP_
 
+#include <adiak.hpp>
+#include <adiak_internal.hpp>
+#include <adiak_tool.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index ecd6e52..0bf9c73 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -2,6 +2,7 @@
 #include "adiak.hpp"
 #include <mpi.h>
 #include <mpi4py/mpi4py.h>
+#include "types.hpp"
 
 #include <algorithm>
 #include <cstdint>
@@ -26,9 +27,9 @@ template <> struct type_caster<mpi4py_comm> {
   bool load(py::handle src, bool) {
     // If the comm is None, produce a mpi4py_comm object with m_comm set to
     // MPI_COMM_NULL
-    if (src == py::none()) {
+    if (src.is(py::none())) {
       value.m_comm = MPI_COMM_NULL;
-      return !PyErr_Occured();
+      return !PyErr_Occurred();
     }
     // Get the underlying PyObject pointer to the mpi4py object
     PyObject *py_capi_comm = src.ptr();
@@ -43,7 +44,7 @@ template <> struct type_caster<mpi4py_comm> {
     }
     // Tell pybind11 that the conversion to C++ was successfull so long as there
     // were no Python errors
-    return !PyErr_Occured();
+    return !PyErr_Occurred();
   }
 
   static py::handle cast(mpi4py_comm src, py::return_value_policy, py::handle) {
@@ -70,32 +71,33 @@ void init(mpi4py_comm comm) {
 }
 
 // Custom version of adiak::value for subclasses of DataContainer
-template <class T, typename = std::enable_if_t<
-                       std::is_templated_base_of<DataContainer, T>::value>>
+template <class T, typename = pybind11::detail::enable_if_t<
+                       is_templated_base_of<DataContainer, T>::value>>
 bool value(std::string name, T value, int category = adiak_general,
            std::string subcategory = "") {
   return adiak::value(name, value.to_adiak(), category, subcategory);
 }
 
-// Custom version of adiak::value for vectors of subclasses of DataContainer
-template <class T, typename = std::enable_if_t<
-                       std::is_templated_base_of<DataContainer, T>::value>>
-bool value_vec(std::string name, std::vector<T> value,
+template <class T, typename = pybind11::detail::enable_if_t<
+                       is_templated_base_of<DataContainer, T>::value>>
+bool value_vec(std::string name, const std::vector<T>& value,
                int category = adiak_general, std::string subcategory = "") {
-  std::vector<std::result_of<decltype (&T::to_adiak)()>::type> adiak_vec;
-  std::transform(value.cbegin(), value.cend(), adiak_vec.cbegin(),
-                 [](T v) { return v.to_adiak(); });
+  using adiak_type = decltype(std::declval<T>().to_adiak());
+  std::vector<adiak_type> adiak_vec;
+  std::transform(value.cbegin(), value.cend(), std::back_inserter(adiak_vec),
+                 [](const T& v) { return v.to_adiak(); });
   return adiak::value(name, adiak_vec, category, subcategory);
 }
 
 // Custom version of adiak::value for sets of subclasses of DataContainer
-template <class T, typename = std::enable_if_t<
-                       std::is_templated_base_of<DataContainer, T>::value>>
-bool value_set(std::string name, std::set<T> value,
+template <class T, typename = pybind11::detail::enable_if_t<
+                       is_templated_base_of<DataContainer, T>::value>>
+bool value_set(std::string name, const std::set<T>& value,
                int category = adiak_general, std::string subcategory = "") {
-  std::set<std::result_of<decltype (&T::to_adiak)()>::type> adiak_set;
-  std::transform(value.cbegin(), value.cend(), adiak_set.cbegin(),
-                 [](T v) { return v.to_adiak(); });
+  using adiak_type = decltype(std::declval<T>().to_adiak());
+  std::set<adiak_type> adiak_set;
+  std::transform(value.cbegin(), value.cend(), std::inserter(adiak_set, adiak_set.end()),
+                 [](const T& v) { return v.to_adiak(); });
   return adiak::value(name, adiak_set, category, subcategory);
 }
 
@@ -131,37 +133,100 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   // We map all these specializations to the Python "value" function.
   // Pybind11 will do the work of selecting the correct version of this
   // function for us.
-  mod.def("value", &adiak::value<int8_t>);
-  mod.def("value", &adiak::value<uint64_t>);
-  mod.def("value", &adiak::value<double>);
-  mod.def("value", &adiak::value<std::string>);
-  mod.def("value", &adiak::python::value<adiak::python::Timepoint>);
-  mod.def("value", &adiak::python::value<adiak::python::Date>);
-  mod.def("value", &adiak::python::value<adiak::python::Version>);
-  mod.def("value", &adiak::python::value<adiak::python::Path>);
-  mod.def("value", &adiak::python::value<adiak::python::CatStr>);
-  mod.def("value", &adiak::python::value<adiak::python::JsonStr>);
-  mod.def("value", &adiak::value<std::vector<int8_t>>);
-  mod.def("value", &adiak::value<std::vector<uint64_t>>);
-  mod.def("value", &adiak::value<std::vector<double>>);
-  mod.def("value", &adiak::value<std::vector<std::string>>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::Timepoint>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::Date>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::Version>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::Path>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::CatStr>);
-  mod.def("value", &adiak::python::value_vec<adiak::python::JsonStr>);
-  mod.def("value", &adiak::value<std::set<int8_t>>);
-  mod.def("value", &adiak::value<std::set<uint64_t>>);
-  mod.def("value", &adiak::value<std::set<double>>);
-  mod.def("value", &adiak::value<std::set<std::string>>);
-  mod.def("value", &adiak::python::value_set<adiak::python::Timepoint>);
-  mod.def("value", &adiak::python::value_set<adiak::python::Date>);
-  mod.def("value", &adiak::python::value_set<adiak::python::Version>);
-  mod.def("value", &adiak::python::value_set<adiak::python::Path>);
-  mod.def("value", &adiak::python::value_set<adiak::python::CatStr>);
-  mod.def("value", &adiak::python::value_set<adiak::python::JsonStr>);
+  mod.def("value", [](const std::string& name, int8_t val) {
+      return adiak::value(name, static_cast<int>(val));
+  });
+  mod.def("value", [](const std::string& name, uint64_t val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, double val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::string& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::Timepoint& val) {
+      return adiak::python::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::Date& val) {
+      return adiak::python::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::Version& val) {
+      return adiak::python::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::Path& val) {
+      return adiak::python::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::CatStr& val) {
+      return adiak::python::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const adiak::python::JsonStr& val) {
+      return adiak::python::value(name, val);
+  });
 
+  mod.def("value", [](const std::string& name, const std::vector<int8_t>& val) {
+      std::vector<int> converted(val.begin(), val.end());
+      return adiak::value(name, converted);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<uint64_t>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<double>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<std::string>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Timepoint>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Date>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Version>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Path>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::CatStr>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::JsonStr>& val) {
+      return adiak::python::value_vec(name, val);
+  });
+
+  mod.def("value", [](const std::string& name, const std::set<int8_t>& val) {
+      std::set<int> converted(val.begin(), val.end());
+      return adiak::value(name, converted);
+  });
+  mod.def("value", [](const std::string& name, const std::set<uint64_t>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<double>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<std::string>& val) {
+      return adiak::value(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Timepoint>& val) {
+      return adiak::python::value_set(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Date>& val) {
+      return adiak::python::value_set(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Version>& val) {
+      return adiak::python::value_set(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Path>& val) {
+      return adiak::python::value_set(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::CatStr>& val) {
+      return adiak::python::value_set(name, val);
+  });
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::JsonStr>& val) {
+      return adiak::python::value_set(name, val);
+  });
   // Bind all the other Adiak functions to custom lambda functions
   // created by the GENERATE_API_CALL_* macros. These labmdas are
   // used over the plain versions of these functions to avoid any issues
diff --git a/src/interface/python/pyadiak/annotations.py b/src/interface/python/pyadiak/annotations.py
index 4cc5046..4c23ca0 100644
--- a/src/interface/python/pyadiak/annotations.py
+++ b/src/interface/python/pyadiak/annotations.py
@@ -73,7 +73,8 @@ def value(name: str, value: Any, category=Category.General, subcategory="") -> b
         raise TypeError(
             f"Invalid type ('{type(subcategory)}') for 'subcategory' parameter. Should be 'str'"
         )
-    return cpp_value(name, wrapped_value, int(category), subcategory)
+    return cpp_value(name, wrapped_value#, int(category), subcategory
+                     )
 
 
 __all__ = [
diff --git a/src/interface/python/pyadiak_tool.cpp b/src/interface/python/pyadiak_tool.cpp
index ce9f211..13586c3 100644
--- a/src/interface/python/pyadiak_tool.cpp
+++ b/src/interface/python/pyadiak_tool.cpp
@@ -63,47 +63,49 @@ py::object convert_adiak_value_to_python(adiak_value_t *val,
   // py::object
   switch (type->dtype) {
   case adiak_long:
-    return py::cast<py::int_>(val->v_long);
+    return py::cast(val->v_long);
     break;
   case adiak_ulong:
-    return py::cast<py::int_>((unsigned long)val->v_long);
+    return py::cast((unsigned long)val->v_long);
     break;
   case adiak_int:
-    return py::cast<py::int_>(val->v_int);
+    return py::cast(val->v_int);
     break;
   case adiak_uint:
-    return py::cast<py::int_>((unsigned int)val->v_int);
+    return py::cast((unsigned int)val->v_int);
     break;
   case adiak_double:
-    return py::cast<py::float_>(val->v_double);
-  case adiak_date:
+    return py::cast(val->v_double);
+  case adiak_date: {
     std::chrono::seconds chrono_seconds(val->v_long);
     return py::cast(adiak::python::Date(
         std::chrono::system_clock::time_point(chrono_seconds)));
     break;
-  case adiak_timeval:
-    uint64_t num_microseconds = val->v_ptr->tv_sec * 1000000;
-    num_microseconds += val->v_ptr->tv_usec;
+  }
+  case adiak_timeval: {
+    struct timeval* tv = static_cast<struct timeval*>(val->v_ptr);
+    uint64_t num_microseconds = tv->tv_sec * 1000000 + tv->tv_usec;
     std::chrono::microseconds chrono_usec(num_microseconds);
     return py::cast(adiak::python::Timepoint(
         std::chrono::system_clock::time_point(chrono_usec)));
     break;
+  }
   case adiak_version:
-    return py::cast(adiak::python::Version(std::string(val->v_ptr)));
+    return py::cast(adiak::python::Version(std::string(static_cast<const char*>(val->v_ptr))));
     break;
   case adiak_string:
-    return py::cast<py::str>(std::string(val->v_ptr));
+    return py::cast(std::string(static_cast<const char*>(val->v_ptr)));
     break;
   case adiak_catstring:
-    return py::cast(adiak::python::CatStr(std::string(val->v_ptr)));
+    return py::cast(adiak::python::CatStr(std::string(static_cast<const char*>(val->v_ptr))));
     break;
   case adiak_jsonstring:
-    return py::cast(adiak::python::JsonStr(std::string(val->v_ptr)));
+    return py::cast(adiak::python::JsonStr(std::string(static_cast<const char*>(val->v_ptr))));
     break;
   case adiak_path:
-    return py::cast(adiak::python::Path(std::string(val->v_ptr)));
+    return py::cast(adiak::python::Path(std::string(static_cast<const char*>(val->v_ptr))));
     break;
-  case adiak_range:
+  case adiak_range: {
     if (type->num_subtypes != 2) {
       throw std::runtime_error(
           "Mismatch in Adiak between 'range' type and number of subtypes");
@@ -111,9 +113,10 @@ py::object convert_adiak_value_to_python(adiak_value_t *val,
     std::tuple<py::object, py::object> range_tuple = std::make_tuple(
         convert_adiak_value_to_python(&(val->v_subval[0]), type->subtype[0]),
         convert_adiak_value_to_python(&(val->v_subval[1]), type->subtype[1]));
-    return py::cast<py::tuple>(range_tuple);
+    return py::cast(range_tuple);
     break;
-  case adiak_set:
+  }
+  case adiak_set: {
     if (type->num_subtypes != 1) {
       throw std::runtime_error(
           "Mismatch in Adiak between 'set' type and number of subtypes");
@@ -126,9 +129,10 @@ py::object convert_adiak_value_to_python(adiak_value_t *val,
       set_val.insert(
           convert_adiak_value_to_python(&(val->v_subval[i]), subtype));
     }
-    return py::cast<py::set>(set_val);
+    return py::cast(set_val);
     break;
-  case adiak_list:
+  }
+  case adiak_list: {
     if (type->num_subtypes != 1) {
       throw std::runtime_error(
           "Mismatch in Adiak between 'list' type and number of subtypes");
@@ -141,15 +145,16 @@ py::object convert_adiak_value_to_python(adiak_value_t *val,
       list_val.push_back(
           convert_adiak_value_to_python(&(val->v_subval[i]), subtype));
     }
-    return py::cast<py::list>(list_val);
+    return py::cast(list_val);
     break;
-  case adiak_tuple:
+  }
+  case adiak_tuple: {
     int num_subtypes = type->num_subtypes;
     int num_elems =
         type->is_reference != 0 ? type->num_ref_elements : type->num_elements;
     if (num_subtypes != num_elems) {
       throw std::runtime_error(
-          "Mismatch in Adiak between 'tuple' type and number of subtypes")
+          "Mismatch in Adiak between 'tuple' type and number of subtypes");
     }
     std::vector<py::object> list_val;
     for (int i = 0; i < num_elems; i++) {
@@ -159,11 +164,12 @@ py::object convert_adiak_value_to_python(adiak_value_t *val,
     py::tuple tup_val = py::cast(list_val);
     return tup_val;
     break;
+  }
   case adiak_longlong:
-    return py::cast<py::int_>(val->v_longlong);
+    return py::cast(val->v_longlong);
     break;
   case adiak_ulonglong:
-    return py::cast<py::int_>(val->v_ulonglong);
+    return py::cast(val->v_longlong);
     break;
   default:
     throw std::runtime_error("Invalid datatype obtained from Adiak");
@@ -262,10 +268,10 @@ void create_adiak_tool_mod(py::module_ &mod) {
            &PyadiakDataType::get_num_subtypes_in_container)
       .def("is_reference", &PyadiakDataType::is_reference)
       .def("get_subtypes", &PyadiakDataType::get_subtypes);
-  m.def("register_cb", &pyadiak_register_cb);
-  m.def("list_namevals", &pyadiak_list_namevals);
-  m.def("type_to_string", &pyadiak_type_to_string);
-  m.def("get_nameval", &pyadiak_get_nameval);
+  mod.def("register_cb", &pyadiak_register_cb);
+  mod.def("list_namevals", &pyadiak_list_namevals);
+  mod.def("type_to_string", &pyadiak_type_to_string);
+  mod.def("get_nameval", &pyadiak_get_nameval);
 }
 
 } // namespace python
diff --git a/src/interface/python/types.cpp b/src/interface/python/types.cpp
index b0db196..737f1eb 100644
--- a/src/interface/python/types.cpp
+++ b/src/interface/python/types.cpp
@@ -21,7 +21,7 @@ Date::Date(std::chrono::system_clock::time_point time)
 
 adiak::date Date::to_adiak() const {
   auto time_since_epoch = std::chrono::duration_cast<std::chrono::seconds>(
-      value.time_since_epoch());
+      m_v.time_since_epoch());
   return adiak::date(time_since_epoch.count());
 }
 
@@ -37,9 +37,7 @@ adiak::path Path::to_adiak() const { return adiak::path(m_v); }
 CatStr::CatStr(const std::string &cs)
     : DataContainer<std::string, adiak::catstring>(cs) {}
 
-adiak::catstringCatStr::to_adiak() const { return adiak::catstring(m_v); }
-
-CatStr::to_adiak() const { return adiak::catstring(m_v); }
+adiak::catstring CatStr::to_adiak() const { return adiak::catstring(m_v); }
 
 JsonStr::JsonStr(const std::string &js)
     : DataContainer<std::string, adiak::jsonstring>(js) {}
@@ -60,19 +58,19 @@ void create_adiak_types_mod(py::module_ &mod) {
       .def("to_python", &adiak::python::Timepoint::to_python);
   py::class_<adiak::python::Date>(mod, "Date")
       .def(py::init<std::chrono::system_clock::time_point>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
+      .def("to_python", &adiak::python::Date::to_python);
   py::class_<adiak::python::Version>(mod, "Version")
       .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
+      .def("to_python", &adiak::python::Version::to_python);
   py::class_<adiak::python::Path>(mod, "Path")
       .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
+      .def("to_python", &adiak::python::Path::to_python);
   py::class_<adiak::python::CatStr>(mod, "CatStr")
       .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
+      .def("to_python", &adiak::python::CatStr::to_python);
   py::class_<adiak::python::JsonStr>(mod, "JsonStr")
       .def(py::init<const std::string &>())
-      .def("to_python", &adiak::python::Timepoint::to_python);
+      .def("to_python", &adiak::python::JsonStr::to_python);
 }
 
 } // namespace python
diff --git a/src/interface/python/types.hpp b/src/interface/python/types.hpp
index 28fbce3..634c315 100644
--- a/src/interface/python/types.hpp
+++ b/src/interface/python/types.hpp
@@ -2,11 +2,27 @@
 #define ADIAK_INTERFACE_PYTHON_TYPES_HPP_
 
 #include "common.hpp"
+#include <pybind11/pybind11.h>
 
 #include <chrono>
 #include <type_traits>
 
 namespace adiak {
+  inline bool operator<(const date& a, const date& b) {
+      return a.v < b.v;
+  }
+  inline bool operator<(const version& a, const version& b) {
+      return a.v < b.v;
+  }
+  inline bool operator<(const path& a, const path& b) {
+      return a.v < b.v;
+  }
+  inline bool operator<(const catstring& a, const catstring& b) {
+      return a.v < b.v;
+  }
+  inline bool operator<(const jsonstring& a, const jsonstring& b) {
+      return a.v < b.v;
+  }
 namespace python {
 
 // The 'is_templated_base_of' type trait is derived from the following
@@ -18,7 +34,7 @@ struct is_templated_base_of_tester;
 
 template <template <typename...> class Base, typename Derived>
 struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<std::is_class<Derived>::value>> : Derived {
+    Base, Derived, pybind11::detail::enable_if_t<std::is_class<Derived>::value>> : Derived {
   template <typename... T> static constexpr std::true_type test(Base<T...> *);
   static constexpr std::false_type test(...);
   using is_base = decltype(test((is_templated_base_of_tester *)nullptr));
@@ -26,7 +42,7 @@ struct is_templated_base_of_tester<
 
 template <template <typename...> class Base, typename Derived>
 struct is_templated_base_of_tester<
-    Base, Derived, std::enable_if_t<!std::is_class<Derived>::value>> {
+    Base, Derived, pybind11::detail::enable_if_t<!std::is_class<Derived>::value>> {
   using is_base = std::false_type;
 };
 
@@ -48,7 +64,7 @@ template <typename T, class adiak_type> struct DataContainer {
 // that will be converted into 'struct timeval' for Adiak
 struct Timepoint : public DataContainer<std::chrono::system_clock::time_point,
                                         struct timeval *> {
-  struct timeval m_time_for_adiak;
+  mutable struct timeval m_time_for_adiak;
 
   Timepoint(std::chrono::system_clock::time_point time);
 
@@ -97,6 +113,27 @@ struct JsonStr : public DataContainer<std::string, adiak::jsonstring> {
   adiak::jsonstring to_adiak() const final;
 };
 
+inline bool operator<(const Timepoint& a, const Timepoint& b) {
+    if (a.m_time_for_adiak.tv_sec != b.m_time_for_adiak.tv_sec)
+        return a.m_time_for_adiak.tv_sec < b.m_time_for_adiak.tv_sec;
+    return a.m_time_for_adiak.tv_usec < b.m_time_for_adiak.tv_usec;
+}
+inline bool operator<(const Date& a, const Date& b) {
+    return a.to_adiak().v < b.to_adiak().v;
+}
+inline bool operator<(const Version& a, const Version& b) {
+    return a.to_adiak().v < b.to_adiak().v;
+}
+inline bool operator<(const Path& a, const Path& b) {
+    return a.to_adiak().v < b.to_adiak().v;
+}
+inline bool operator<(const CatStr& a, const CatStr& b) {
+    return a.to_adiak().v < b.to_adiak().v;
+}
+inline bool operator<(const JsonStr& a, const JsonStr& b) {
+    return a.to_adiak().v < b.to_adiak().v;
+}
+
 void create_adiak_types_mod(py::module_ &mod);
 
 } // namespace python

From 8d0abd416e44994bab94e9a7f7a4b0389e376551 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Tue, 5 Aug 2025 16:33:57 -0700
Subject: [PATCH 10/22] Fix definitions for 4 args

---
 src/interface/python/pyadiak.cpp            | 122 ++++++++++----------
 src/interface/python/pyadiak/annotations.py |   3 +-
 2 files changed, 61 insertions(+), 64 deletions(-)

diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index 0bf9c73..617d1a5 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -133,99 +133,97 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   // We map all these specializations to the Python "value" function.
   // Pybind11 will do the work of selecting the correct version of this
   // function for us.
-  mod.def("value", [](const std::string& name, int8_t val) {
-      return adiak::value(name, static_cast<int>(val));
+  mod.def("value", [](const std::string& name, int8_t val, int category, const std::string& subcategory) {
+      return adiak::value(name, static_cast<int>(val), category, subcategory);
   });
-  mod.def("value", [](const std::string& name, uint64_t val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, uint64_t val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, double val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, double val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::string& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::string& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::Timepoint& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::Timepoint& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::Date& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::Date& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::Version& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::Version& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::Path& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::Path& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::CatStr& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::CatStr& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const adiak::python::JsonStr& val) {
-      return adiak::python::value(name, val);
+  mod.def("value", [](const std::string& name, const adiak::python::JsonStr& val, int category, const std::string& subcategory) {
+      return adiak::python::value(name, val, category, subcategory);
   });
-
-  mod.def("value", [](const std::string& name, const std::vector<int8_t>& val) {
+  mod.def("value", [](const std::string& name, const std::vector<int8_t>& val, int category, const std::string& subcategory) {
       std::vector<int> converted(val.begin(), val.end());
-      return adiak::value(name, converted);
+      return adiak::value(name, converted, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<uint64_t>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<uint64_t>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<double>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<double>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<std::string>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<std::string>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Timepoint>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Timepoint>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Date>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Date>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Version>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Version>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Path>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::Path>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::CatStr>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::CatStr>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<adiak::python::JsonStr>& val) {
-      return adiak::python::value_vec(name, val);
+  mod.def("value", [](const std::string& name, const std::vector<adiak::python::JsonStr>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_vec(name, val, category, subcategory);
   });
-
-  mod.def("value", [](const std::string& name, const std::set<int8_t>& val) {
+  mod.def("value", [](const std::string& name, const std::set<int8_t>& val, int category, const std::string& subcategory) {
       std::set<int> converted(val.begin(), val.end());
-      return adiak::value(name, converted);
+      return adiak::value(name, converted, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<uint64_t>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::set<uint64_t>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<double>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::set<double>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<std::string>& val) {
-      return adiak::value(name, val);
+  mod.def("value", [](const std::string& name, const std::set<std::string>& val, int category, const std::string& subcategory) {
+      return adiak::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::Timepoint>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Timepoint>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::Date>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Date>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::Version>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Version>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::Path>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::Path>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::CatStr>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::CatStr>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<adiak::python::JsonStr>& val) {
-      return adiak::python::value_set(name, val);
+  mod.def("value", [](const std::string& name, const std::set<adiak::python::JsonStr>& val, int category, const std::string& subcategory) {
+      return adiak::python::value_set(name, val, category, subcategory);
   });
   // Bind all the other Adiak functions to custom lambda functions
   // created by the GENERATE_API_CALL_* macros. These labmdas are
diff --git a/src/interface/python/pyadiak/annotations.py b/src/interface/python/pyadiak/annotations.py
index 4c23ca0..4cc5046 100644
--- a/src/interface/python/pyadiak/annotations.py
+++ b/src/interface/python/pyadiak/annotations.py
@@ -73,8 +73,7 @@ def value(name: str, value: Any, category=Category.General, subcategory="") -> b
         raise TypeError(
             f"Invalid type ('{type(subcategory)}') for 'subcategory' parameter. Should be 'str'"
         )
-    return cpp_value(name, wrapped_value#, int(category), subcategory
-                     )
+    return cpp_value(name, wrapped_value, int(category), subcategory)
 
 
 __all__ = [

From c04e009bd2abe7411cebbbf68dddd41bece3d785 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Wed, 6 Aug 2025 20:04:28 -0700
Subject: [PATCH 11/22] Add fini

---
 src/interface/python/pyadiak/annotations.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/interface/python/pyadiak/annotations.py b/src/interface/python/pyadiak/annotations.py
index 4cc5046..e483bd6 100644
--- a/src/interface/python/pyadiak/annotations.py
+++ b/src/interface/python/pyadiak/annotations.py
@@ -36,8 +36,13 @@
 from pyadiak.__pyadiak_impl.annotations import (
     value as cpp_value,
 )
+from pyadiak.__pyadiak_impl.annotations import (
+    fini as cpp_fini,
+)
 from pyadiak.types import *
 
+def fini():
+    cpp_fini()
 
 def init(comm=None):
     try:

From fb282ab4481c14e9e4b68eaf50dcecc215364c1e Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 21 Aug 2025 13:16:55 -0700
Subject: [PATCH 12/22] Change types

---
 src/interface/python/pyadiak.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index 617d1a5..d923441 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -123,7 +123,7 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   mod.def("init", &adiak::python::init);
   mod.def("fini", GENERATE_API_CALL_NO_ARGS(fini));
   // Python has no concept of templates, so pybind11 requires
-  // us to specify the types for all template functions. The requires us to
+  // us to specify the types for all template functions. This requires us to
   // iterate over all acceptable value types for adiak::value.
   //
   // Because we need to use Python-compatible types everywhere,
@@ -133,10 +133,10 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   // We map all these specializations to the Python "value" function.
   // Pybind11 will do the work of selecting the correct version of this
   // function for us.
-  mod.def("value", [](const std::string& name, int8_t val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, int val, int category, const std::string& subcategory) {
       return adiak::value(name, static_cast<int>(val), category, subcategory);
   });
-  mod.def("value", [](const std::string& name, uint64_t val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, unsigned int val, int category, const std::string& subcategory) {
       return adiak::value(name, val, category, subcategory);
   });
   mod.def("value", [](const std::string& name, double val, int category, const std::string& subcategory) {
@@ -163,11 +163,11 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   mod.def("value", [](const std::string& name, const adiak::python::JsonStr& val, int category, const std::string& subcategory) {
       return adiak::python::value(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<int8_t>& val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, const std::vector<int>& val, int category, const std::string& subcategory) {
       std::vector<int> converted(val.begin(), val.end());
       return adiak::value(name, converted, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::vector<uint64_t>& val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, const std::vector<unsigned int>& val, int category, const std::string& subcategory) {
       return adiak::value(name, val, category, subcategory);
   });
   mod.def("value", [](const std::string& name, const std::vector<double>& val, int category, const std::string& subcategory) {
@@ -194,11 +194,11 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   mod.def("value", [](const std::string& name, const std::vector<adiak::python::JsonStr>& val, int category, const std::string& subcategory) {
       return adiak::python::value_vec(name, val, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<int8_t>& val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, const std::set<int>& val, int category, const std::string& subcategory) {
       std::set<int> converted(val.begin(), val.end());
       return adiak::value(name, converted, category, subcategory);
   });
-  mod.def("value", [](const std::string& name, const std::set<uint64_t>& val, int category, const std::string& subcategory) {
+  mod.def("value", [](const std::string& name, const std::set<unsigned int>& val, int category, const std::string& subcategory) {
       return adiak::value(name, val, category, subcategory);
   });
   mod.def("value", [](const std::string& name, const std::set<double>& val, int category, const std::string& subcategory) {

From 0e9ce2086c2f39f70df9fa803bce9a3f373ff657 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 21 Aug 2025 13:20:51 -0700
Subject: [PATCH 13/22] Change WITH -> ENABLE

---
 .github/workflows/cmake.yml | 2 +-
 CMakeLists.txt              | 4 ++--
 src/CMakeLists.txt          | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 67f28e3..2f574c5 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -73,7 +73,7 @@ jobs:
       # Note the current convention is to use the -S and -B options here to specify source 
       # and build directories, but this is only available with CMake 3.13 and higher.  
       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DWITH_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir)
+      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DENABLE_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir)
 
     - name: Build
       working-directory: ${{github.workspace}}/build
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 22146de..394c3d8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,9 +36,9 @@ endif()
 
 include(${BLT_SOURCE_DIR}/SetupBLT.cmake)
 
-option(WITH_PYTHON_BINDINGS "Build/Install Python bindings for Adiak" FALSE)
+option(ENABLE_PYTHON_BINDINGS "Build/Install Python bindings for Adiak" FALSE)
 
-if (WITH_PYTHON_BINDINGS)
+if (ENABLE_PYTHON_BINDINGS)
   find_package(Python COMPONENTS Interpreter Development REQUIRED)
   find_package(pybind11 CONFIG REQUIRED)
   
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f4f9988..ddf63d8 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -54,6 +54,6 @@ install(TARGETS
 
 install(EXPORT adiak-targets NAMESPACE adiak:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/adiak)
 
-if (WITH_PYTHON_BINDINGS)
+if (ENABLE_PYTHON_BINDINGS)
   add_subdirectory(interface/python)
 endif()

From 0632d27e9c03f8795b5539847b536b9f94c8bc52 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 21 Aug 2025 13:34:11 -0700
Subject: [PATCH 14/22] Add docpage

---
 docs/sphinx/PythonSupport.rst | 28 ++++++++++++++++++++++++++++
 docs/sphinx/index.rst         |  1 +
 2 files changed, 29 insertions(+)
 create mode 100644 docs/sphinx/PythonSupport.rst

diff --git a/docs/sphinx/PythonSupport.rst b/docs/sphinx/PythonSupport.rst
new file mode 100644
index 0000000..9db3bde
--- /dev/null
+++ b/docs/sphinx/PythonSupport.rst
@@ -0,0 +1,28 @@
+Python support
+==============
+
+Adiak provides Python bindings based on `pybind11 <https://pybind11.readthedocs.io/en/stable/>`_.
+To build Adiak with Python support, enable
+the :code:`ENABLE_PYTHON_BINDINGS` option in the CMake configuration:
+
+.. code-block:: sh
+
+    $ cmake -DENABLE_PYTHON_BINDINGS=On ..
+
+Using the Python module
+-----------------------
+
+The Python module requires pybind11 and an installation of Python that both supports
+pybind11 and provides development headers (e.g., :code:`Python.h`) and libraries
+(e.g., :code:`libpython3.8.so`).
+
+The Adiak Python module is installed in either :code:`lib/pythonX.Y/site-packages/` and/or
+:code:`lib64/pythonX.Y/site-packages` in the Adiak installation directory. In these paths,
+:code:`X.Y` corresponds to the major and minor version numbers of the Python installation used.
+Additionally, :code:`lib/` and :code:`lib64/` will be used in accordance with the configuration
+of the Python installed.
+
+To use the Adiak Python module, simply add the directories above to :code:`PYTHONPATH` or
+:code:`sys.path`. Note that the module will be automatically added to :code:`PYTHONPATH` when
+loading the Adiak package with Spack if the :code:`python` variant is enabled.
+The module can then be imported with :code:`import pyadiak`.
diff --git a/docs/sphinx/index.rst b/docs/sphinx/index.rst
index 0b32d94..d8a1771 100644
--- a/docs/sphinx/index.rst
+++ b/docs/sphinx/index.rst
@@ -33,6 +33,7 @@ by printf-inspired strings.
    ToolsUsingAdiak
    ApplicationAPI
    ToolAPI
+   PythonSupport
 
 Contributing
 ==================

From 7012aa955807d2dd0255bcfedb1a2bb470e5a39c Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 21 Aug 2025 14:15:05 -0700
Subject: [PATCH 15/22] Allow nompi and update test

---
 .github/workflows/cmake.yml      | 25 ++++++++++++++++++++++---
 src/CMakeLists.txt               |  3 +++
 src/interface/python/pyadiak.cpp | 25 ++++++++++++++++++++-----
 3 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 2f574c5..579ca6e 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -26,19 +26,31 @@ jobs:
               name: "Ubuntu Latest GCC",
               os: ubuntu-latest,
               build_type: "Release", cc: "gcc", cxx: "g++",
-              mpi_type: "mpich"
+              mpi_type: "none"
             }
           - {
               name: "Ubuntu Latest Clang",
               os: ubuntu-latest,
               build_type: "Release", cc: "clang", cxx: "clang++",
+              mpi_type: "none"
+            }
+          - {
+              name: "Ubuntu Latest GCC (MPI)",
+              os: ubuntu-latest,
+              build_type: "Release", cc: "gcc", cxx: "g++",
+              mpi_type: "mpich"
+            }
+          - {
+              name: "Ubuntu Latest Clang (MPI)",
+              os: ubuntu-latest,
+              build_type: "Release", cc: "clang", cxx: "clang++",
               mpi_type: "mpich"
             }
           - {
               name: "macOS Latest Clang",
               os: macos-latest,
               build_type: "Release", cc: "clang", cxx: "clang++",
-              mpi_type: "mpich"
+              mpi_type: "none"
             }
     steps:
     - name: Checkout repository and submodules
@@ -52,6 +64,7 @@ jobs:
         python-version: '3.13'
 
     - name: Install MPI
+      if: ${{ matrix.config.mpi != "none" }}
       uses: mpi4py/setup-mpi@v1.3.2
       with:
         mpi: ${{matrix.config.mpi_type}}
@@ -73,7 +86,13 @@ jobs:
       # Note the current convention is to use the -S and -B options here to specify source 
       # and build directories, but this is only available with CMake 3.13 and higher.  
       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DENABLE_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir)
+      run: |
+        EXTRA_OPTS=""
+        if [ "${{ matrix.config.mpi }}" != "none" ]; then
+          EXTRA_OPTS="-DENABLE_MPI=ON"
+        fi
+        cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DENABLE_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir) \
+          $EXTRA_OPTS
 
     - name: Build
       working-directory: ${{github.workspace}}/build
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ddf63d8..8704ea9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -56,4 +56,7 @@ install(EXPORT adiak-targets NAMESPACE adiak:: DESTINATION ${CMAKE_INSTALL_LIBDI
 
 if (ENABLE_PYTHON_BINDINGS)
   add_subdirectory(interface/python)
+  if (MPI_FOUND)
+    find_package(MPI REQUIRED CXX)
+  endif()
 endif()
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index d923441..1e2ac78 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -1,7 +1,9 @@
 #include "pyadiak.hpp"
 #include "adiak.hpp"
-#include <mpi.h>
-#include <mpi4py/mpi4py.h>
+#if defined(ENABLE_MPI)
+    #include <mpi.h>
+    #include <mpi4py/mpi4py.h>
+#endif
 #include "types.hpp"
 
 #include <algorithm>
@@ -13,14 +15,20 @@
 struct mpi4py_comm {
   mpi4py_comm() = default;
 
-  mpi4py_comm(MPI_Comm comm) : m_comm(comm) {}
-
-  MPI_Comm m_comm;
+  #if defined(ENABLE_MPI)
+    mpi4py_comm(MPI_Comm comm) : m_comm(comm) {}
+    MPI_Comm m_comm;
+  #else
+    // no-op placeholder so the type still compiles
+    mpi4py_comm(int /*unused*/ = 0) {}
+    std::nullptr_t m_comm = nullptr;
+  #endif
 };
 
 namespace pybind11 {
 namespace detail {
 
+#if defined(ENABLE_MPI)
 template <> struct type_caster<mpi4py_comm> {
   PYBIND11_TYPE_CASTER(mpi4py_comm, _("mpi4py_comm"));
 
@@ -51,6 +59,7 @@ template <> struct type_caster<mpi4py_comm> {
     return PyMPIComm_New(src.m_comm);
   }
 };
+#endif
 
 } // namespace detail
 } // namespace pybind11
@@ -63,11 +72,15 @@ namespace python {
 // type_caster above to decide whether to pass an MPI communicator
 // to adiak::init
 void init(mpi4py_comm comm) {
+#if defined(ENABLE_MPI)
   if (comm.m_comm == MPI_COMM_NULL) {
     adiak::init(nullptr);
   } else {
     adiak::init(&comm.m_comm);
   }
+#else
+  adiak::init(comm.m_comm);
+#endif
 }
 
 // Custom version of adiak::value for subclasses of DataContainer
@@ -114,10 +127,12 @@ bool value_set(std::string name, const std::set<T>& value,
 void create_adiak_annotation_mod(py::module_ &mod) {
   // Try to import mpi4py so that we can early abort if
   // we can't properly create bindings
+  #if defined(ENABLE_MPI)
   if (import_mpi4py() < 0) {
     throw std::runtime_error(
         "Cannot load mpi4py within the Adiak Python bindings");
   }
+  #endif
 
   // Bind 'init' and 'fini'
   mod.def("init", &adiak::python::init);

From 46f8657cdd140f9e3571d61b42ef41cea61b4465 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 21 Aug 2025 18:38:53 -0700
Subject: [PATCH 16/22] Fix CI syntax and other issues

---
 .github/workflows/cmake.yml | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 579ca6e..53070e3 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -64,14 +64,19 @@ jobs:
         python-version: '3.13'
 
     - name: Install MPI
-      if: ${{ matrix.config.mpi != "none" }}
+      if: ${{ matrix.config.mpi_type != 'none' }}
       uses: mpi4py/setup-mpi@v1.3.2
       with:
         mpi: ${{matrix.config.mpi_type}}
           
     - name: Install Python binding dependencies
       run: |
-        python3 -m pip install pybind11 mpi4py
+        python3 -m pip install pybind11
+
+    - name: Install mpi4py
+      if: ${{ matrix.config.mpi_type != 'none' }}
+      run: |
+        python -m pip install mpi4py
 
     - name: Create Build Environment
       # Some projects don't allow in-source building, so create a separate build directory
@@ -88,7 +93,7 @@ jobs:
       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
       run: |
         EXTRA_OPTS=""
-        if [ "${{ matrix.config.mpi }}" != "none" ]; then
+        if [ "${{ matrix.config.mpi_type }}" != "none" ]; then
           EXTRA_OPTS="-DENABLE_MPI=ON"
         fi
         cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_C_COMPILER=${{matrix.config.cc}} -DCMAKE_CXX_COMPILER=${{matrix.config.cxx}} -DENABLE_PYTHON_BINDINGS=ON -Dpybind11_DIR=$(pybind11-config --cmakedir) \

From 6f35f298405e2348944006e6d2b5971526a5c2f1 Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 25 Sep 2025 19:13:40 -0700
Subject: [PATCH 17/22] Fix cray build error

---
 src/interface/python/pyadiak.cpp | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index 1e2ac78..1f68d6a 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -9,6 +9,9 @@
 #include <algorithm>
 #include <cstdint>
 #include <set>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 // Bindings for MPI Comm derived from this StackOverflow post:
 // https://stackoverflow.com/a/62449190
@@ -83,31 +86,32 @@ void init(mpi4py_comm comm) {
 #endif
 }
 
-// Custom version of adiak::value for subclasses of DataContainer
-template <class T, typename = pybind11::detail::enable_if_t<
-                       is_templated_base_of<DataContainer, T>::value>>
-bool value(std::string name, T value, int category = adiak_general,
+// Custom version of adiak::value for types that provide .to_adiak()
+// Use detection instead of inheritance to improve portability across compilers.
+template <class T, class U = decltype(std::declval<const T&>().to_adiak())>
+bool value(std::string name, const T& value, int category = adiak_general,
            std::string subcategory = "") {
+  (void)sizeof(U); // participates in overload resolution only if to_adiak() is valid
   return adiak::value(name, value.to_adiak(), category, subcategory);
 }
 
-template <class T, typename = pybind11::detail::enable_if_t<
-                       is_templated_base_of<DataContainer, T>::value>>
+template <class T, class U = decltype(std::declval<const T&>().to_adiak())>
 bool value_vec(std::string name, const std::vector<T>& value,
                int category = adiak_general, std::string subcategory = "") {
-  using adiak_type = decltype(std::declval<T>().to_adiak());
+  (void)sizeof(U);
+  using adiak_type = decltype(std::declval<const T&>().to_adiak());
   std::vector<adiak_type> adiak_vec;
   std::transform(value.cbegin(), value.cend(), std::back_inserter(adiak_vec),
                  [](const T& v) { return v.to_adiak(); });
   return adiak::value(name, adiak_vec, category, subcategory);
 }
 
-// Custom version of adiak::value for sets of subclasses of DataContainer
-template <class T, typename = pybind11::detail::enable_if_t<
-                       is_templated_base_of<DataContainer, T>::value>>
+// Custom version of adiak::value for sets of types that provide .to_adiak()
+template <class T, class U = decltype(std::declval<const T&>().to_adiak())>
 bool value_set(std::string name, const std::set<T>& value,
                int category = adiak_general, std::string subcategory = "") {
-  using adiak_type = decltype(std::declval<T>().to_adiak());
+  (void)sizeof(U);
+  using adiak_type = decltype(std::declval<const T&>().to_adiak());
   std::set<adiak_type> adiak_set;
   std::transform(value.cbegin(), value.cend(), std::inserter(adiak_set, adiak_set.end()),
                  [](const T& v) { return v.to_adiak(); });

From 5187189bac3235ea1713cc36d762a9d67b4242ad Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 25 Sep 2025 20:40:14 -0700
Subject: [PATCH 18/22] define enable_mpi

---
 CMakeLists.txt | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 394c3d8..e79a1e6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,6 +58,13 @@ if (ENABLE_DOCS)
   add_subdirectory(docs)
 endif()
 
+option(ENABLE_MPI "Enable MPI support" FALSE)
+
+if(ENABLE_MPI)
+  add_definitions(-DENABLE_MPI)
+  find_package(MPI REQUIRED)
+endif()
+
 include(CMakePackageConfigHelpers)
 
 # Configure adiak-config-version.cmake

From 9857e3b6f73ff1256720b60d40cc0652ade90a8b Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Thu, 25 Sep 2025 21:11:23 -0700
Subject: [PATCH 19/22] Undo change and custom type cast

---
 CMakeLists.txt                   |  7 -------
 src/interface/python/pyadiak.cpp | 24 ++++++++++++++++++++++--
 2 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e79a1e6..394c3d8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,13 +58,6 @@ if (ENABLE_DOCS)
   add_subdirectory(docs)
 endif()
 
-option(ENABLE_MPI "Enable MPI support" FALSE)
-
-if(ENABLE_MPI)
-  add_definitions(-DENABLE_MPI)
-  find_package(MPI REQUIRED)
-endif()
-
 include(CMakePackageConfigHelpers)
 
 # Configure adiak-config-version.cmake
diff --git a/src/interface/python/pyadiak.cpp b/src/interface/python/pyadiak.cpp
index 1f68d6a..3560d00 100644
--- a/src/interface/python/pyadiak.cpp
+++ b/src/interface/python/pyadiak.cpp
@@ -138,8 +138,28 @@ void create_adiak_annotation_mod(py::module_ &mod) {
   }
   #endif
 
-  // Bind 'init' and 'fini'
-  mod.def("init", &adiak::python::init);
+#if defined(ENABLE_MPI)
+  // Robust overload that accepts mpi4py.MPI.Comm (or None) without needing a type_caster
+  mod.def("init", [](py::object comm_obj) {
+  if (comm_obj.is_none()) {
+    adiak::init(nullptr);
+    return;
+  }
+  // Validate it is an mpi4py.MPI.Comm and extract the MPI_Comm
+  PyObject* obj = comm_obj.ptr();
+  if (!PyObject_TypeCheck(obj, &PyMPIComm_Type)) {
+    throw py::type_error("adiak.init expects mpi4py.MPI.Comm or None");
+  }
+  MPI_Comm comm = *PyMPIComm_Get(obj);
+  adiak::init(&comm);
+});
+#else
+  // Non-MPI build: accept anything and ignore (acts like None)
+  mod.def("init", [](py::object) {
+    adiak::init(nullptr);
+  });
+#endif
+
   mod.def("fini", GENERATE_API_CALL_NO_ARGS(fini));
   // Python has no concept of templates, so pybind11 requires
   // us to specify the types for all template functions. This requires us to

From 7cb8c49c905fc4a170b1cc6ea6b1b88f6b10e5ed Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Mon, 6 Oct 2025 22:52:56 -0700
Subject: [PATCH 20/22] Add python test

---
 src/interface/python/CMakeLists.txt |  9 ++++
 tests/CMakeLists.txt                | 36 +++++++++++++++-
 tests/testapp.py                    | 64 +++++++++++++++++++++++++++++
 3 files changed, 108 insertions(+), 1 deletion(-)
 create mode 100644 tests/testapp.py

diff --git a/src/interface/python/CMakeLists.txt b/src/interface/python/CMakeLists.txt
index 5c44765..f4cfe33 100644
--- a/src/interface/python/CMakeLists.txt
+++ b/src/interface/python/CMakeLists.txt
@@ -57,3 +57,12 @@ install(
     LIBRARY DESTINATION
         ${PYADIAK_SITEARCH}
 )
+
+# Put the compiled extension inside the pyadiak package in the build tree
+set(_py_pkg_dir "${CMAKE_BINARY_DIR}/src/interface/python/pyadiak")
+
+set_target_properties(__pyadiak_impl PROPERTIES
+  LIBRARY_OUTPUT_DIRECTORY  "${_py_pkg_dir}"   # where the .so (MODULE/LIBRARY) goes
+  RUNTIME_OUTPUT_DIRECTORY  "${_py_pkg_dir}"
+  ARCHIVE_OUTPUT_DIRECTORY  "${_py_pkg_dir}"
+)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5d61a80..db21dc5 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -20,4 +20,38 @@ blt_add_executable(NAME test_adiak
     SOURCES test_application-api.cpp 
     DEPENDS_ON adiak gtest)
 blt_add_test(NAME test_adiak
-    COMMAND test_adiak)
\ No newline at end of file
+    COMMAND test_adiak)
+
+# Python testing
+find_package(Python COMPONENTS Interpreter REQUIRED)
+
+set(_py_root ${CMAKE_BINARY_DIR}/src/interface/python)
+set(_py_pkg  ${_py_root}/pyadiak)
+set(_libdir  ${CMAKE_BINARY_DIR}/lib)
+
+# Serial (works with ENABLE_MPI=OFF)
+blt_add_test(
+  NAME test_python_serial
+  COMMAND
+    ${CMAKE_COMMAND} -E env
+      PYTHONPATH=${_py_root}:$ENV{PYTHONPATH}
+      LD_LIBRARY_PATH=${_libdir}:$ENV{LD_LIBRARY_PATH}
+      ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testapp.py
+  DEPENDS_ON __pyadiak_impl
+  WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+
+if(ENABLE_MPI)
+  blt_add_test(
+    NAME test_python_mpi
+    COMMAND
+      ${CMAKE_COMMAND} -E env
+        ADIAK_TEST_MPI=1
+        PYTHONPATH=${_py_root}:$ENV{PYTHONPATH}
+        LD_LIBRARY_PATH=${_libdir}:$ENV{LD_LIBRARY_PATH}
+        ${Python_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testapp.py
+    NUM_MPI_TASKS 2
+    DEPENDS_ON __pyadiak_impl
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+  )
+endif()
diff --git a/tests/testapp.py b/tests/testapp.py
new file mode 100644
index 0000000..1e151e6
--- /dev/null
+++ b/tests/testapp.py
@@ -0,0 +1,64 @@
+import os
+
+# Optional MPI
+USE_MPI = os.environ.get("ADIAK_TEST_MPI", "0") == "1"
+MPI = None
+if USE_MPI:
+    try:
+        from mpi4py import MPI  # noqa: F401
+    except Exception:
+        USE_MPI = False
+        MPI = None
+
+from pyadiak.annotations import (
+    init, value, fini,
+    collect_all, walltime, cputime, systime, Version
+)
+
+def must_ok(ok, what):
+    if not ok:
+        raise AssertionError(f"adiak call failed: {what}")
+
+def main():
+    comm = MPI.COMM_WORLD if USE_MPI else None
+    init(comm)
+
+    # --- Scalars
+    must_ok(value("str", "s"), "value(str)")
+    must_ok(value("compiler", Version("gcc@8.1.0")), "value(Version)")
+    must_ok(value("mydouble", 3.14), "value(double)")
+    must_ok(value("problemsize", 14000), "value(int)")
+    must_ok(value("countdown", 9876543210), "value(large int)")
+
+    # --- Flat containers
+    grid = [4.5, 1.18, 0.24, 8.92]
+    must_ok(value("gridvalues", grid), "value(list[float])")
+
+    names = {"matt", "david", "greg"}
+    must_ok(value("allnames", names), "value(set[str])")
+
+    # --- “points” and “antipoints”
+    # Option A: parallel arrays (simple)
+    ap_a = ["first", "second", "third"]
+    ap_b = [1.0, 2.0, 3.0]
+    ap_c = [1.0, 4.0, 9.0]
+    must_ok(value("points.names", ap_a), "value(points.names)")
+    must_ok(value("points.x", ap_b),     "value(points.x)")
+    must_ok(value("points.y", ap_c),     "value(points.y)")
+    must_ok(value("antipoints.a", ap_a), "value(antipoints.a)")
+    must_ok(value("antipoints.b", ap_b), "value(antipoints.b)")
+    must_ok(value("antipoints.c", ap_c), "value(antipoints.c)")
+
+    floatar = [0.01, 0.02, 0.03]
+    must_ok(value("floats", floatar), "value(list[float])")
+
+    # System collectors / timers (if bound; they are in your annotations)
+    must_ok(collect_all(), "collect_all()")
+    must_ok(walltime(), "walltime()")
+    must_ok(cputime(), "cputime()")
+    must_ok(systime(), "systime()")
+
+    fini()
+
+if __name__ == "__main__":
+    main()

From 2d34128ddd5b9fcdd47b30e4ee1834e711370bdf Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Mon, 6 Oct 2025 23:04:51 -0700
Subject: [PATCH 21/22] Add example

---
 docs/sphinx/PythonSupport.rst | 82 ++++++++++++++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 2 deletions(-)

diff --git a/docs/sphinx/PythonSupport.rst b/docs/sphinx/PythonSupport.rst
index 9db3bde..abedbad 100644
--- a/docs/sphinx/PythonSupport.rst
+++ b/docs/sphinx/PythonSupport.rst
@@ -1,13 +1,22 @@
 Python support
 ==============
 
-Adiak provides Python bindings based on `pybind11 <https://pybind11.readthedocs.io/en/stable/>`_.
+Adiak provides Python bindings based on `pybind11 <https://pybind11.readthedocs.io/en/stable/>`_
+for the metadata/annotation APIs (``init``, ``value``, ``fini``) and a set of convenience
+collectors (e.g., ``collect_all()``, ``walltime()``).
 To build Adiak with Python support, enable
 the :code:`ENABLE_PYTHON_BINDINGS` option in the CMake configuration:
 
 .. code-block:: sh
 
-    $ cmake -DENABLE_PYTHON_BINDINGS=On ..
+    $ cmake -DENABLE_PYTHON_BINDINGS=ON ..
+
+If you want to initialize Adiak with an MPI communicator from Python, also enable (or auto-detect)
+MPI at configure time (mpi4py is only needed at runtime if you actually pass a communicator):
+
+.. code-block:: sh
+
+    $ cmake -DENABLE_PYTHON_BINDINGS=ON -DENABLE_MPI=ON ..
 
 Using the Python module
 -----------------------
@@ -26,3 +35,72 @@ To use the Adiak Python module, simply add the directories above to :code:`PYTHO
 :code:`sys.path`. Note that the module will be automatically added to :code:`PYTHONPATH` when
 loading the Adiak package with Spack if the :code:`python` variant is enabled.
 The module can then be imported with :code:`import pyadiak`.
+
+Example: basic usage (serial)
+-----------------------------
+
+.. code-block:: python
+
+    from datetime import datetime
+    from pathlib import Path
+
+    from pyadiak.annotations import init, value, fini, collect_all, walltime, cputime, systime
+    from pyadiak.types import Version, Path as APath, CatStr, Category
+
+    def main():
+        init(None)  # serial mode
+
+        value("str", "s")
+        value("compiler", Version("gcc@8.1.0"))
+        value("mydouble", 3.14)
+        value("problemsize", 14000, category=Category.Tuning)
+        value("countdown", 9876543210)
+
+        grid = [4.5, 1.18, 0.24, 8.92]
+        value("gridvalues", grid)
+
+        names = {"bob", "jim", "greg"}
+        value("allnames", names)
+
+        # Flatten nested structures (or use JsonStr)
+        names_arr = ["first", "second", "third"]
+        xs = [1.0, 2.0, 3.0]
+        ys = [1.0, 4.0, 9.0]
+        value("points.names", names_arr)
+        value("points.x", xs)
+        value("points.y", ys)
+
+        # Time & paths are auto-wrapped; shown explicitly here for clarity
+        value("birthday", datetime.fromtimestamp(286551000))   # Timepoint
+        value("nullpath", APath(Path("/dev/null")))            # Path
+        value("githash", CatStr("a0c93767478f23602c2eb317f641b091c52cf374"))
+
+        collect_all()
+        walltime()
+        cputime()
+        systime()
+
+        fini()
+
+    if __name__ == "__main__":
+        main()
+
+
+Example: MPI usage (optional)
+-----------------------------
+
+If built with :code:`-DENABLE_MPI=ON` and :code:`mpi4py` is available:
+
+.. code-block:: python
+
+    from mpi4py import MPI
+    from pyadiak.annotations import init, value, fini
+
+    def main():
+        comm = MPI.COMM_WORLD
+        init(comm)           # initialize with communicator
+        value("rank", comm.Get_rank())
+        fini()
+
+    if __name__ == "__main__":
+        main()

From 252ad44edfe7638d0c1d6ab9c06d3d0d78ec664d Mon Sep 17 00:00:00 2001
From: Michael McKinsey <michaelmckinsey1@gmail.com>
Date: Tue, 14 Oct 2025 16:59:45 -0700
Subject: [PATCH 22/22] Bump version

---
 .github/workflows/cmake.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index 140c5a9..f61a277 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -65,7 +65,7 @@ jobs:
 
     - name: Install MPI
       if: ${{ matrix.config.mpi_type != 'none' }}
-      uses: mpi4py/setup-mpi@v1.3.2
+      uses: mpi4py/setup-mpi@v1.3.5
       with:
         mpi: ${{matrix.config.mpi_type}}