Revert "Implement Python Import Caching"

tools/python_api/CMakeLists.txt

@@ -9,8 +9,6 @@ file(GLOB SOURCE_PY
 pybind11_add_module(_kuzu
         SHARED
         src_cpp/kuzu_binding.cpp
-        src_cpp/cached_import/py_cached_item.cpp
-        src_cpp/cached_import/py_cached_import.cpp
         src_cpp/py_connection.cpp
         src_cpp/py_database.cpp
         src_cpp/py_prepared_statement.cpp

tools/python_api/src_cpp/include/py_database.h

@@ -19,7 +19,7 @@ class PyDatabase {
     explicit PyDatabase(const std::string& databasePath, uint64_t bufferPoolSize,
         uint64_t maxNumThreads, bool compression, bool readOnly);
 
-    ~PyDatabase();
+    ~PyDatabase() = default;
 
     template<class T>
     void scanNodeTable(const std::string& tableName, const std::string& propName,

tools/python_api/src_cpp/pandas/pandas_analyzer.cpp

@@ -1,7 +1,6 @@
 #include "pandas/pandas_analyzer.h"
 
 #include "function/built_in_function_utils.h"
-#include "cached_import/py_cached_import.h"
 #include "py_conversion.h"
 
 namespace kuzu {
@@ -38,7 +37,7 @@ common::LogicalType PandasAnalyzer::getListType(py::object& ele, bool& canConver
     for (auto pyVal : ele) {
         auto object = py::reinterpret_borrow<py::object>(pyVal);
         auto itemType = getItemType(object, canConvert);
-        if (i == 0) {
+        if (i != 0) {
             listType = itemType;
         } else {
             if (!upgradeType(listType, itemType)) {
@@ -89,8 +88,8 @@ static py::object findFirstNonNull(const py::handle& row, uint64_t numRows) {
 
 common::LogicalType PandasAnalyzer::innerAnalyze(py::object column, bool& canConvert) {
     auto numRows = py::len(column);
-    auto pandasModule = importCache->pandas;
-    auto pandasSeries = pandasModule.core.series.Series();
+    auto pandasModule = py::module::import("pandas");
+    auto pandasSeries = pandasModule.attr("core").attr("series").attr("Series");
 
     if (py::isinstance(column, pandasSeries)) {
         column = column.attr("__array__")();

tools/python_api/src_cpp/pandas/pandas_scan.cpp

@@ -1,7 +1,6 @@
 #include "pandas/pandas_scan.h"
 
 #include "function/table/bind_input.h"
-#include "cached_import/py_cached_import.h"
 #include "numpy/numpy_scan.h"
 #include "py_connection.h"
 #include "pybind11/pytypes.h"
@@ -128,9 +127,10 @@ std::unique_ptr<Value> tryReplacePD(py::dict& dict, py::str& tableName) {
 }
 
 std::unique_ptr<common::Value> replacePD(common::Value* value) {
+    py::gil_scoped_acquire acquire;
     auto pyTableName = py::str(value->getValue<std::string>());
     // Here we do an exhaustive search on the frame lineage.
-    auto currentFrame = importCache->inspect.currentframe()();
+    auto currentFrame = py::module::import("inspect").attr("currentframe")();
     while (hasattr(currentFrame, "f_locals")) {
         auto localDict = py::reinterpret_borrow<py::dict>(currentFrame.attr("f_locals"));
         if (localDict) {

tools/python_api/src_cpp/py_connection.cpp

@@ -4,14 +4,12 @@
 
 #include "common/string_format.h"
 #include "datetime.h" // from Python
-#include "cached_import/py_cached_import.h"
 #include "main/connection.h"
 #include "pandas/pandas_scan.h"
 #include "processor/result/factorized_table.h"
 #include "common/types/uuid.h"
 
 using namespace kuzu::common;
-using namespace kuzu;
 
 void PyConnection::initialize(py::handle& m) {
     py::class_<PyConnection>(m, "Connection")
@@ -153,7 +151,9 @@ void PyConnection::getAllEdgesForTorchGeometric(py::array_t<int64_t>& npArray,
 }
 
 bool PyConnection::isPandasDataframe(const py::object& object) {
-    return py::isinstance(object, importCache->pandas.DataFrame());
+    // TODO(Ziyi): introduce PythonCachedImport to avoid unnecessary import.
+    py::module pandas = py::module::import("pandas");
+    return py::isinstance(object, pandas.attr("DataFrame"));
 }
 
 static Value transformPythonValue(py::handle val);
@@ -176,10 +176,11 @@ std::unordered_map<std::string, std::unique_ptr<Value>> transformPythonParameter
 }
 
 Value transformPythonValue(py::handle val) {
-    auto datetime_datetime = importCache->datetime.datetime();
-    auto time_delta = importCache->datetime.timedelta();
-    auto datetime_date = importCache->datetime.date();
-    auto uuid = importCache->uuid.UUID();
+    auto datetime_mod = py::module::import("datetime");
+    auto datetime_datetime = datetime_mod.attr("datetime");
+    auto time_delta = datetime_mod.attr("timedelta");
+    auto datetime_date = datetime_mod.attr("date");
+    auto uuid = py::module::import("uuid").attr("UUID");
     if (py::isinstance<py::bool_>(val)) {
         return Value::createValue<bool>(val.cast<bool>());
     } else if (py::isinstance<py::int_>(val)) {

tools/python_api/src_cpp/py_conversion.cpp

@@ -1,18 +1,18 @@
 #include "py_conversion.h"
 
 #include "common/type_utils.h"
-#include "cached_import/py_cached_import.h"
 
 namespace kuzu {
 
 using namespace kuzu::common;
-using kuzu::importCache;
 
 PythonObjectType getPythonObjectType(py::handle& ele) {
-    auto pandasNa = importCache->pandas.NA();
-    auto pyDateTime = importCache->datetime.datetime();
-    auto pandasNat = importCache->pandas.NaT();
-    auto pyDate = importCache->datetime.date();
+    py::object pandas = py::module::import("pandas");
+    auto pandasNa = pandas.attr("NA");
+    auto pandasNat = pandas.attr("NaT");
+    py::object datetime = py::module::import("datetime");
+    auto pyDateTime = datetime.attr("datetime");
+    auto pyDate = datetime.attr("date");
     if (ele.is_none() || ele.is(pandasNa) || ele.is(pandasNat)) {
         return PythonObjectType::None;
     } else if (py::isinstance<py::bool_>(ele)) {

tools/python_api/src_cpp/py_database.cpp

@@ -1,6 +1,4 @@
 #include "include/py_database.h"
-
-#include "include/cached_import/py_cached_import.h"
 #include "pandas/pandas_scan.h"
 
 #include <memory>
@@ -39,11 +37,6 @@ PyDatabase::PyDatabase(const std::string& databasePath, uint64_t bufferPoolSize,
     database = std::make_unique<Database>(databasePath, systemConfig);
     database->addBuiltInFunction(READ_PANDAS_FUNC_NAME, kuzu::PandasScanFunction::getFunctionSet());
     storageDriver = std::make_unique<kuzu::main::StorageDriver>(database.get());
-    kuzu::importCache = std::make_shared<kuzu::PythonCachedImport>();
-}
-
-PyDatabase::~PyDatabase() {
-    kuzu::importCache.reset();
 }
 
 template<class T>