pynect 0.2.6 → 0.2.9

package/src/native/python_bridge.cpp

@@ -6,12 +6,14 @@
 #include "python_bridge.h"
 #include "gil_guard.h"
 #include "type_converter.h"
+#include "callback_bridge.h"
 
 #include <Python.h>
 #include <sstream>
 #include <stdexcept>
 #include <iostream>
 #include <algorithm>
+#include <fstream>
 
 #if defined(__linux__) || defined(__APPLE__)
 #include <dlfcn.h>
@@ -21,6 +23,40 @@ namespace pynect {
 
 namespace {
 
+void setEnvironmentVariable(const std::string& key, const std::string& value) {
+#ifdef _WIN32
+  _putenv_s(key.c_str(), value.c_str());
+#else
+  setenv(key.c_str(), value.c_str(), 1);
+#endif
+}
+
+PyObject* evaluateSource(
+  const std::string& source,
+  const std::string& filename,
+  const char* mode,
+  PyObject* globals
+) {
+  PyObject* builtins = PyImport_ImportModule("builtins");
+  if (!builtins) return nullptr;
+  PyRef builtinsRef = PyRef::steal(builtins);
+
+  PyObject* compile = PyObject_GetAttrString(builtins, "compile");
+  if (!compile) return nullptr;
+  PyRef compileRef = PyRef::steal(compile);
+
+  PyObject* code = PyObject_CallFunction(
+    compile,
+    "sss",
+    source.c_str(),
+    filename.c_str(),
+    mode
+  );
+  if (!code) return nullptr;
+  PyRef codeRef = PyRef::steal(code);
+  return PyEval_EvalCode(code, globals, globals);
+}
+
 #if defined(__linux__) || defined(__APPLE__)
 void promotePythonLibrary(const std::string& libraryPath) {
   if (libraryPath.empty()) {
@@ -60,6 +96,8 @@ PythonBridge& PythonBridge::getInstance() {
 void PythonBridge::initializePython(
   const std::string& pythonHome,
   const std::string& pythonExecutable,
+  const std::string& pythonBaseExecutable,
+  const std::string& pythonPrefix,
   const std::string& pythonLibrary,
   const std::vector<std::string>& extraSysPaths,
   const std::vector<std::pair<std::string, std::string>>& envVars
@@ -74,52 +112,57 @@ void PythonBridge::initializePython(
 
   // Set environment variables before initialization
   for (const auto& [key, val] : envVars) {
-#ifdef _WIN32
-    _putenv_s(key.c_str(), val.c_str());
-#else
-    setenv(key.c_str(), val.c_str(), 1);
-#endif
+    setEnvironmentVariable(key, val);
   }
 
-  // Configure the interpreter with the detected executable so CPython can
-  // resolve its standard library consistently across platforms.
-  PyConfig config;
-  PyConfig_InitPythonConfig(&config);
-  PyStatus status = PyConfig_SetBytesString(
-    &config,
-    &config.program_name,
-    pythonExecutable.c_str()
-  );
-  if (!PyStatus_Exception(status) && !pythonHome.empty()) {
-    status = PyConfig_SetBytesString(&config, &config.home, pythonHome.c_str());
-  }
-  if (!PyStatus_Exception(status)) {
-    status = Py_InitializeFromConfig(&config);
+  // These process-wide setters are in Python's Stable ABI. Keep their decoded
+  // storage alive until finalization, as required by CPython.
+  _programName = Py_DecodeLocale(pythonExecutable.c_str(), nullptr);
+  if (!_programName) {
+    throw std::runtime_error("Failed to decode the Python executable path");
   }
-  std::string configError = PyStatus_Exception(status) && status.err_msg
-    ? status.err_msg
-    : "";
-  PyConfig_Clear(&config);
-  if (PyStatus_Exception(status)) {
-    throw std::runtime_error("Failed to configure Python: " + configError);
+  Py_SetProgramName(_programName);
+  if (!pythonHome.empty()) {
+    _pythonHome = Py_DecodeLocale(pythonHome.c_str(), nullptr);
+    if (!_pythonHome) {
+      throw std::runtime_error("Failed to decode the Python home path");
+    }
+    Py_SetPythonHome(_pythonHome);
   }
+  Py_Initialize();
 
   if (!Py_IsInitialized()) {
     throw std::runtime_error("Failed to initialize Python interpreter");
   }
 
-  // Enable thread support
-  PyEval_InitThreads();
-
   // Save main thread state and release GIL so threads can run
   _mainThreadState = PyEval_SaveThread();
 
-  // Add extra sys.path entries (done with GIL held)
-  if (!extraSysPaths.empty()) {
+  // Restore the selected environment identity and add its import paths after
+  // Stable ABI initialization used the base installation for the stdlib.
+  {
     GILAcquire gil;
     PyObject* sysModule = PyImport_ImportModule("sys");
     if (sysModule) {
       PyRef sysRef = PyRef::steal(sysModule);
+      PyObject* executable = PyUnicode_FromString(pythonExecutable.c_str());
+      if (executable) {
+        PyRef executableRef = PyRef::steal(executable);
+        PyObject_SetAttrString(sysModule, "executable", executable);
+      }
+      PyObject* baseExecutable = PyUnicode_FromString(pythonBaseExecutable.c_str());
+      if (baseExecutable) {
+        PyRef baseExecutableRef = PyRef::steal(baseExecutable);
+        PyObject_SetAttrString(sysModule, "_base_executable", baseExecutable);
+      }
+      if (!pythonPrefix.empty()) {
+        PyObject* prefix = PyUnicode_FromString(pythonPrefix.c_str());
+        if (prefix) {
+          PyRef prefixRef = PyRef::steal(prefix);
+          PyObject_SetAttrString(sysModule, "prefix", prefix);
+          PyObject_SetAttrString(sysModule, "exec_prefix", prefix);
+        }
+      }
       PyObject* sysPath = PyObject_GetAttrString(sysModule, "path");
       if (sysPath) {
         PyRef pathRef = PyRef::steal(sysPath);
@@ -131,6 +174,23 @@ void PythonBridge::initializePython(
           }
         }
       }
+      PyObject* siteModule = PyImport_ImportModule("site");
+      if (siteModule) {
+        PyRef siteRef = PyRef::steal(siteModule);
+        PyObject* addSiteDirectory = PyObject_GetAttrString(siteModule, "addsitedir");
+        if (addSiteDirectory) {
+          PyRef addSiteDirectoryRef = PyRef::steal(addSiteDirectory);
+          for (const auto& p : extraSysPaths) {
+            PyObject* added = PyObject_CallFunction(addSiteDirectory, "s", p.c_str());
+            if (added) Py_DECREF(added);
+            else PyErr_Clear();
+          }
+        } else {
+          PyErr_Clear();
+        }
+      } else {
+        PyErr_Clear();
+      }
     }
   }
 
@@ -203,8 +263,7 @@ TaskResult PythonBridge::_makeSuccessResult(PyObject* obj) {
   }
 
   // For callable objects
-  if (PyCallable_Check(obj) && !PyFunction_Check(obj) &&
-      !PyModule_Check(obj) && !PyType_Check(obj)) {
+  if (PyCallable_Check(obj) && !PyModule_Check(obj) && !PyType_Check(obj)) {
     // Instance of a class with __call__ - usually want as reference
     result.objectId = TypeConverter::registerObject(obj);
     result.isObject = true;
@@ -563,7 +622,11 @@ bool PythonBridge::_buildCallArgs(
       argsOut = nullptr;
       return false;
     }
-    PyTuple_SET_ITEM(argsOut, static_cast<Py_ssize_t>(i), arg);  // steals reference
+    if (PyTuple_SetItem(argsOut, static_cast<Py_ssize_t>(i), arg) != 0) {
+      Py_DECREF(argsOut);
+      argsOut = nullptr;
+      return false;
+    }
   }
 
   // Build kwargs dict
@@ -626,6 +689,9 @@ PyObject* PythonBridge::_deserialize(const SerializedValue& value) {
     case SerializedFormat::NONE:
       Py_RETURN_NONE;
 
+    case SerializedFormat::JS_CALLBACK:
+      return createPythonCallback(value.metadata.callbackId);
+
     default:
       // Try JSON fallback
       if (!value.jsonData.empty()) {
@@ -635,6 +701,14 @@ PyObject* PythonBridge::_deserialize(const SerializedValue& value) {
   }
 }
 
+TaskResult PythonBridge::serializeValue(PyObject* obj) {
+  return _makeSuccessResult(obj);
+}
+
+PyObject* PythonBridge::deserializeValue(const SerializedValue& value) {
+  return _deserialize(value);
+}
+
 // Code Execution
 
 TaskResult PythonBridge::runCodeSync(const std::string& code) {
@@ -643,7 +717,7 @@ TaskResult PythonBridge::runCodeSync(const std::string& code) {
 
   PyObject* globalDict = PyModule_GetDict(mainModule);  // borrowed
 
-  PyObject* result = PyRun_String(code.c_str(), Py_file_input, globalDict, globalDict);
+  PyObject* result = evaluateSource(code, "<pynect>", "exec", globalDict);
   if (!result) {
     return _makeErrorResult();
   }
@@ -661,7 +735,7 @@ TaskResult PythonBridge::evalExpressionSync(const std::string& expression) {
 
   PyObject* globalDict = PyModule_GetDict(mainModule);  // borrowed
 
-  PyObject* result = PyRun_String(expression.c_str(), Py_eval_input, globalDict, globalDict);
+  PyObject* result = evaluateSource(expression, "<pynect>", "eval", globalDict);
   if (!result) {
     return _makeErrorResult();
   }
@@ -671,8 +745,8 @@ TaskResult PythonBridge::evalExpressionSync(const std::string& expression) {
 }
 
 TaskResult PythonBridge::runFileSync(const std::string& filePath) {
-  FILE* fp = fopen(filePath.c_str(), "r");
-  if (!fp) {
+  std::ifstream input(filePath, std::ios::binary);
+  if (!input) {
     TaskResult r;
     r.success = false;
     r.errorType = "FileNotFoundError";
@@ -680,11 +754,14 @@ TaskResult PythonBridge::runFileSync(const std::string& filePath) {
     return r;
   }
 
+  std::ostringstream source;
+  source << input.rdbuf();
+
   PyObject* mainModule = PyImport_AddModule("__main__");
+  if (!mainModule) return _makeErrorResult();
   PyObject* globalDict = PyModule_GetDict(mainModule);
 
-  PyObject* result = PyRun_File(fp, filePath.c_str(), Py_file_input, globalDict, globalDict);
-  fclose(fp);
+  PyObject* result = evaluateSource(source.str(), filePath, "exec", globalDict);
 
   if (!result) {
     return _makeErrorResult();
@@ -763,7 +840,7 @@ TaskResult PythonBridge::getObjectKeysSync(uint32_t objectId) {
     PyObject* name = PyList_GetItem(dirList, i);
     if (!name || !PyUnicode_Check(name)) continue;
 
-    const char* nameStr = PyUnicode_AsUTF8(name);
+    const char* nameStr = PyUnicode_AsUTF8AndSize(name, nullptr);
     if (!nameStr) continue;
 
     // Filter out private names

package/src/native/python_bridge.h

@@ -27,6 +27,7 @@ struct CallOptions {
   std::vector<std::pair<std::string, SerializedValue>> kwargs;
   uint32_t timeoutMs = 0;
   uint32_t executionTimeoutMs = 0;
+  uint32_t callbackDepth = 0;
   std::string requestId;
 };
 
@@ -67,6 +68,8 @@ public:
   void initializePython(
     const std::string& pythonHome,
     const std::string& pythonExecutable,
+    const std::string& pythonBaseExecutable,
+    const std::string& pythonPrefix,
     const std::string& pythonLibrary,
     const std::vector<std::string>& extraSysPaths,
     const std::vector<std::pair<std::string, std::string>>& envVars
@@ -212,6 +215,12 @@ public:
   void collectGarbage();
   size_t getTrackedObjectCount() const;
 
+  /** Serialize a callback argument using the normal Python -> JavaScript rules. */
+  TaskResult serializeValue(PyObject* obj);
+
+  /** Deserialize a JavaScript callback result using the normal argument rules. */
+  PyObject* deserializeValue(const SerializedValue& value);
+
 private:
   PythonBridge() = default;
   ~PythonBridge() = default;
@@ -253,6 +262,10 @@ private:
 
   bool _initialized = false;
   PyThreadState* _mainThreadState = nullptr;
+  // CPython requires these buffers to remain unchanged for the process
+  // lifetime, so the singleton intentionally retains them after finalization.
+  wchar_t* _programName = nullptr;
+  wchar_t* _pythonHome = nullptr;
 
   // Iterator registry: iteratorId -> Python iterator object
   std::map<uint32_t, PyObject*> _iterators;

package/src/native/thread_pool.cpp

@@ -178,72 +178,79 @@ void PythonThreadPool::_workerThread(uint32_t threadId) {
       _stats.currentQueueSize.fetch_sub(1, std::memory_order_relaxed);
     }
 
-    // Check timeout before executing
-    if (_isTimedOut(task)) {
-      TaskResult timeoutResult;
-      timeoutResult.success = false;
-      timeoutResult.errorType = "TimeoutError";
-      timeoutResult.errorMessage = "Python task timed out after " +
-                                    std::to_string(task.timeoutMs) + "ms in queue";
-      timeoutResult.errorTraceback = "";
-      _stats.totalTasksTimedOut.fetch_add(1, std::memory_order_relaxed);
-      _postResult(task.id, std::move(timeoutResult), std::move(task.callback));
-      continue;
-    }
-
-    // Execute the task with GIL held
-    _stats.activeThreads.fetch_add(1, std::memory_order_relaxed);
-
-    auto startTime = std::chrono::steady_clock::now();
-    TaskResult result;
-
-    try {
-      // Acquire GIL - critical: must be released when we're done
+    {
       GILAcquire gil;
-
-      // Check timeout again (task might have waited in queue)
-      if (task.timeoutMs > 0 && _isTimedOut(task)) {
-        result.success = false;
-        result.errorType = "TimeoutError";
-        result.errorMessage = "Python task timed out";
-        result.errorTraceback = "";
-      } else {
-        // Execute the Python work
-        result = task.work();
-      }
-    } catch (const std::exception& e) {
-      result.success = false;
-      result.errorType = "RuntimeError";
-      result.errorMessage = std::string("C++ exception in worker thread: ") + e.what();
-      result.errorTraceback = "";
-    } catch (...) {
-      result.success = false;
-      result.errorType = "RuntimeError";
-      result.errorMessage = "Unknown C++ exception in worker thread";
-      result.errorTraceback = "";
+      _executeTask(std::move(task));
     }
+  }
+}
 
-    auto endTime = std::chrono::steady_clock::now();
-    auto durationUs = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime).count();
-    _stats.totalExecutionTimeUs.fetch_add(static_cast<uint64_t>(durationUs), std::memory_order_relaxed);
+void PythonThreadPool::_executeTask(PythonTask task) {
+  _stats.activeThreads.fetch_add(1, std::memory_order_relaxed);
+  const auto startTime = std::chrono::steady_clock::now();
+  TaskResult result;
 
-    if (result.success) {
-      _stats.totalTasksCompleted.fetch_add(1, std::memory_order_relaxed);
+  try {
+    if (_isTimedOut(task)) {
+      result.success = false;
+      result.errorType = "TimeoutError";
+      result.errorMessage = "Python task timed out after " +
+        std::to_string(task.timeoutMs) + "ms in queue";
+      _stats.totalTasksTimedOut.fetch_add(1, std::memory_order_relaxed);
     } else {
-      _stats.totalTasksFailed.fetch_add(1, std::memory_order_relaxed);
+      result = task.work();
     }
+  } catch (const std::exception& e) {
+    result.success = false;
+    result.errorType = "RuntimeError";
+    result.errorMessage = std::string("C++ exception in worker thread: ") + e.what();
+  } catch (...) {
+    result.success = false;
+    result.errorType = "RuntimeError";
+    result.errorMessage = "Unknown C++ exception in worker thread";
+  }
 
-    _stats.activeThreads.fetch_sub(1, std::memory_order_relaxed);
+  const auto durationUs = std::chrono::duration_cast<std::chrono::microseconds>(
+    std::chrono::steady_clock::now() - startTime
+  ).count();
+  _stats.totalExecutionTimeUs.fetch_add(static_cast<uint64_t>(durationUs), std::memory_order_relaxed);
+  if (result.success) _stats.totalTasksCompleted.fetch_add(1, std::memory_order_relaxed);
+  else _stats.totalTasksFailed.fetch_add(1, std::memory_order_relaxed);
+  _stats.activeThreads.fetch_sub(1, std::memory_order_relaxed);
+  _postResult(task.id, std::move(result), std::move(task.callback));
 
-    // Post result back to Node.js event loop
-    _postResult(task.id, std::move(result), std::move(task.callback));
+  if (_draining.load()) _drainCv.notify_all();
+}
 
-    // Signal drain waiters
-    if (_draining.load()) {
-      std::lock_guard<std::mutex> lock(_queueMutex);
-      _drainCv.notify_all();
+void PythonThreadPool::pumpUntil(const std::atomic<bool>& completed) {
+  PyThreadState* state = PyEval_SaveThread();
+  while (!completed.load(std::memory_order_acquire) && _running.load()) {
+    PythonTask task;
+    bool hasTask = false;
+    {
+      std::unique_lock<std::mutex> lock(_queueMutex);
+      _queueCv.wait(lock, [this, &completed] {
+        return completed.load(std::memory_order_acquire) ||
+          !_queue.empty() || !_running.load();
+      });
+      if (!completed.load(std::memory_order_acquire) && !_queue.empty()) {
+        task = std::move(_queue.front());
+        _queue.pop_front();
+        _stats.currentQueueSize.fetch_sub(1, std::memory_order_relaxed);
+        hasTask = true;
+      }
+    }
+    if (hasTask) {
+      PyEval_RestoreThread(state);
+      _executeTask(std::move(task));
+      state = PyEval_SaveThread();
     }
   }
+  PyEval_RestoreThread(state);
+}
+
+void PythonThreadPool::notifyWaiters() {
+  _queueCv.notify_all();
 }
 
 // Result Delivery

package/src/native/thread_pool.h

@@ -144,10 +144,23 @@ public:
   /** Check if pool is running */
   bool isRunning() const noexcept { return _running.load(); }
 
+  /**
+   * Release the GIL and keep servicing queued Python work until a JavaScript
+   * callback completes. This preserves progress for reentrant calls even with
+   * a one-thread pool.
+   */
+  void pumpUntil(const std::atomic<bool>& completed);
+
+  /** Wake workers that may be waiting for callback completion. */
+  void notifyWaiters();
+
 private:
   /** Worker thread entry point */
   void _workerThread(uint32_t threadId);
 
+  /** Execute and deliver one task while the caller holds the GIL. */
+  void _executeTask(PythonTask task);
+
   /** Post result back to event loop via libuv */
   void _postResult(uint64_t taskId, TaskResult result, std::function<void(TaskResult)> callback);
 

package/src/native/type_converter.cpp

@@ -106,14 +106,19 @@ void TypeConverter::clearRegistry() {
 
 std::string TypeConverter::getTypeName(PyObject* obj) {
   if (!obj) return "NoneType";
-  PyObject* type = reinterpret_cast<PyObject*>(Py_TYPE(obj));
+  PyObject* type = PyObject_Type(obj);
+  if (!type) {
+    PyErr_Clear();
+    return "unknown";
+  }
+  PyRef typeRef = PyRef::steal(type);
   PyObject* name = PyObject_GetAttrString(type, "__name__");
   if (!name) {
     PyErr_Clear();
     return "unknown";
   }
   PyRef nameRef = PyRef::steal(name);
-  const char* str = PyUnicode_AsUTF8(name);
+  const char* str = PyUnicode_AsUTF8AndSize(name, nullptr);
   if (!str) {
     PyErr_Clear();
     return "unknown";
@@ -123,7 +128,12 @@ std::string TypeConverter::getTypeName(PyObject* obj) {
 
 std::string TypeConverter::getQualifiedTypeName(PyObject* obj) {
   if (!obj) return "NoneType";
-  PyObject* type = reinterpret_cast<PyObject*>(Py_TYPE(obj));
+  PyObject* type = PyObject_Type(obj);
+  if (!type) {
+    PyErr_Clear();
+    return "unknown";
+  }
+  PyRef typeRef = PyRef::steal(type);
 
   // Try __module__.__qualname__ first
   PyObject* module = PyObject_GetAttrString(type, "__module__");
@@ -132,13 +142,13 @@ std::string TypeConverter::getQualifiedTypeName(PyObject* obj) {
 
   std::string result;
   if (module && PyUnicode_Check(module)) {
-    const char* mod = PyUnicode_AsUTF8(module);
+    const char* mod = PyUnicode_AsUTF8AndSize(module, nullptr);
     if (mod) {
       result = std::string(mod) + ".";
     }
   }
   if (qualname && PyUnicode_Check(qualname)) {
-    const char* qn = PyUnicode_AsUTF8(qualname);
+    const char* qn = PyUnicode_AsUTF8AndSize(qualname, nullptr);
     if (qn) result += qn;
   } else {
     result += getTypeName(obj);
@@ -249,7 +259,7 @@ SerializedValue TypeConverter::pythonToSerialized(PyObject* obj, int depth) {
         if (strObj) {
           PyRef strRef = PyRef::steal(strObj);
           result.format = SerializedFormat::JSON;
-          result.jsonData = "\"" + std::string(PyUnicode_AsUTF8(strObj)) + "\"";
+          result.jsonData = "\"" + std::string(PyUnicode_AsUTF8AndSize(strObj, nullptr)) + "\"";
           return result;
         }
       }
@@ -286,7 +296,7 @@ SerializedValue TypeConverter::pythonToSerialized(PyObject* obj, int depth) {
 
   // String
   if (PyUnicode_Check(obj)) {
-    const char* str = PyUnicode_AsUTF8(obj);
+    const char* str = PyUnicode_AsUTF8AndSize(obj, nullptr);
     if (!str) {
       PyErr_Clear();
       result.format = SerializedFormat::JSON;
@@ -420,13 +430,13 @@ std::string TypeConverter::dictToJson(PyObject* mapping, int depth) {
     // Convert key to string
     std::string keyStr;
     if (PyUnicode_Check(key)) {
-      const char* k = PyUnicode_AsUTF8(key);
+      const char* k = PyUnicode_AsUTF8AndSize(key, nullptr);
       if (k) keyStr = k;
     } else {
       PyObject* strKey = PyObject_Str(key);
       if (strKey) {
         PyRef strRef = PyRef::steal(strKey);
-        const char* k = PyUnicode_AsUTF8(strKey);
+        const char* k = PyUnicode_AsUTF8AndSize(strKey, nullptr);
         if (k) keyStr = k;
       } else {
         PyErr_Clear();
@@ -470,7 +480,7 @@ SerializedValue TypeConverter::numpyArrayToBuffer(PyObject* array) {
     PyObject* dtypeName = PyObject_GetAttrString(dtypeObj, "name");
     if (dtypeName) {
       PyRef nameRef = PyRef::steal(dtypeName);
-      const char* name = PyUnicode_AsUTF8(dtypeName);
+      const char* name = PyUnicode_AsUTF8AndSize(dtypeName, nullptr);
       if (name) result.metadata.dtype = name;
     } else { PyErr_Clear(); }
   } else { PyErr_Clear(); }
@@ -538,7 +548,7 @@ SerializedValue TypeConverter::dataFrameToBuffer(PyObject* df) {
         for (Py_ssize_t i = 0; i < ncols; ++i) {
           PyObject* col = PyList_GetItem(colList, i);
           if (col && PyUnicode_Check(col)) {
-            const char* colName = PyUnicode_AsUTF8(col);
+            const char* colName = PyUnicode_AsUTF8AndSize(col, nullptr);
             if (colName) result.metadata.columns.push_back(colName);
           }
         }
@@ -565,7 +575,7 @@ SerializedValue TypeConverter::dataFrameToBuffer(PyObject* df) {
 
     if (jsonStr) {
       PyRef jsonRef = PyRef::steal(jsonStr);
-      const char* json = PyUnicode_AsUTF8(jsonStr);
+      const char* json = PyUnicode_AsUTF8AndSize(jsonStr, nullptr);
       if (json) {
         result.jsonData = json;
         result.format = SerializedFormat::PANDAS_DATAFRAME;
@@ -588,7 +598,7 @@ SerializedValue TypeConverter::seriesToBuffer(PyObject* series) {
     PyObject* jsonStr = PyObject_CallNoArgs(toJson);
     if (jsonStr) {
       PyRef jsonRef = PyRef::steal(jsonStr);
-      const char* json = PyUnicode_AsUTF8(jsonStr);
+      const char* json = PyUnicode_AsUTF8AndSize(jsonStr, nullptr);
       if (json) result.jsonData = json;
     } else { PyErr_Clear(); }
   } else { PyErr_Clear(); }
@@ -598,7 +608,7 @@ SerializedValue TypeConverter::seriesToBuffer(PyObject* series) {
   if (nameObj && nameObj != Py_None) {
     PyRef nameRef = PyRef::steal(nameObj);
     if (PyUnicode_Check(nameObj)) {
-      const char* name = PyUnicode_AsUTF8(nameObj);
+      const char* name = PyUnicode_AsUTF8AndSize(nameObj, nullptr);
       if (name) result.metadata.columns.push_back(name);
     }
   } else if (nameObj) {
@@ -634,7 +644,7 @@ PyObject* TypeConverter::jsonToPython(const std::string& json) {
   }
   PyRef strRef = PyRef::steal(strObj);
 
-  PyObject* result = PyObject_CallOneArg(loads, strObj);
+  PyObject* result = PyObject_CallFunctionObjArgs(loads, strObj, nullptr);
   if (!result) {
     PyErr_Clear();
     Py_RETURN_NONE;
@@ -747,7 +757,7 @@ PyObject* TypeConverter::bufferToNumpyArray(
       }
       PyRef shapeListRef = PyRef::steal(shapeList);
 
-      PyObject* reshaped = PyObject_CallOneArg(reshape, shapeList);
+      PyObject* reshaped = PyObject_CallFunctionObjArgs(reshape, shapeList, nullptr);
       if (reshaped) {
         return reshaped;
       }
@@ -770,7 +780,7 @@ std::string TypeConverter::getRepr(PyObject* obj) {
     return "<error getting repr>";
   }
   PyRef reprRef = PyRef::steal(repr);
-  const char* str = PyUnicode_AsUTF8(repr);
+  const char* str = PyUnicode_AsUTF8AndSize(repr, nullptr);
   if (!str) {
     PyErr_Clear();
     return "<encoding error>";
@@ -786,7 +796,7 @@ std::string TypeConverter::getStr(PyObject* obj) {
     return "<error>";
   }
   PyRef strRef = PyRef::steal(str);
-  const char* cstr = PyUnicode_AsUTF8(str);
+  const char* cstr = PyUnicode_AsUTF8AndSize(str, nullptr);
   if (!cstr) {
     PyErr_Clear();
     return "";
@@ -815,7 +825,7 @@ std::tuple<std::string, std::string, std::string> TypeConverter::captureExceptio
     PyObject* name = PyObject_GetAttrString(excType, "__name__");
     if (name) {
       PyRef nameRef = PyRef::steal(name);
-      const char* n = PyUnicode_AsUTF8(name);
+      const char* n = PyUnicode_AsUTF8AndSize(name, nullptr);
       if (n) typeName = n;
     } else { PyErr_Clear(); }
   }
@@ -825,7 +835,7 @@ std::tuple<std::string, std::string, std::string> TypeConverter::captureExceptio
     PyObject* str = PyObject_Str(excValue);
     if (str) {
       PyRef strRef = PyRef::steal(str);
-      const char* s = PyUnicode_AsUTF8(str);
+      const char* s = PyUnicode_AsUTF8AndSize(str, nullptr);
       if (s) message = s;
     } else { PyErr_Clear(); }
   }
@@ -838,7 +848,7 @@ std::tuple<std::string, std::string, std::string> TypeConverter::captureExceptio
       PyObject* formatTb = PyObject_GetAttrString(tbModule, "format_tb");
       if (formatTb) {
         PyRef formatTbRef = PyRef::steal(formatTb);
-        PyObject* tbLines = PyObject_CallOneArg(formatTb, excTb);
+        PyObject* tbLines = PyObject_CallFunctionObjArgs(formatTb, excTb, nullptr);
         if (tbLines) {
           PyRef tbLinesRef = PyRef::steal(tbLines);
           std::ostringstream oss;
@@ -847,7 +857,7 @@ std::tuple<std::string, std::string, std::string> TypeConverter::captureExceptio
           for (Py_ssize_t i = 0; i < nlines; ++i) {
             PyObject* line = PyList_GetItem(tbLines, i);
             if (line && PyUnicode_Check(line)) {
-              const char* l = PyUnicode_AsUTF8(line);
+              const char* l = PyUnicode_AsUTF8AndSize(line, nullptr);
               if (l) oss << l;
             }
           }