Sikuwa first commit

cpp_cache/pysmartcache_simple.cpp

@@ -0,0 +1,221 @@
+// sikuwa/cpp_cache/pysmartcache_simple.cpp
+// 简化版智能缓存系统的Python扩展
+
+#include <Python.h>
+#include "smart_cache_simple.h"
+
+// 为LRUCache和BuildCache创建Python对象类型
+
+// 简单的Python扩展，仅提供基本功能
+
+// LRUCache相关函数
+
+static PyObject* py_lru_cache_new(PyObject* self, PyObject* args) {
+    int max_size = 1000;
+    if (!PyArg_ParseTuple(args, "|i", &max_size)) {
+        return nullptr;
+    }
+    
+    LRUCache* cache = new LRUCache(max_size);
+    return PyCapsule_New(cache, "LRUCache", [](PyObject* capsule) {
+        LRUCache* cache = static_cast<LRUCache*>(PyCapsule_GetPointer(capsule, "LRUCache"));
+        delete cache;
+    });
+}
+
+static PyObject* py_lru_cache_put(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    const char* key;
+    const char* value;
+    if (!PyArg_ParseTuple(args, "Os|s", &capsule, &key, &value)) {
+        return nullptr;
+    }
+    
+    LRUCache* cache = static_cast<LRUCache*>(PyCapsule_GetPointer(capsule, "LRUCache"));
+    if (cache == nullptr) {
+        return nullptr;
+    }
+    
+    bool success = cache->put(key, value ? value : "");
+    return PyBool_FromLong(success);
+}
+
+static PyObject* py_lru_cache_get(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    const char* key;
+    if (!PyArg_ParseTuple(args, "Os", &capsule, &key)) {
+        return nullptr;
+    }
+    
+    LRUCache* cache = static_cast<LRUCache*>(PyCapsule_GetPointer(capsule, "LRUCache"));
+    if (cache == nullptr) {
+        return nullptr;
+    }
+    
+    std::string result = cache->get(key);
+    if (result.empty()) {
+        Py_RETURN_NONE;
+    }
+    
+    return PyUnicode_FromString(result.c_str());
+}
+
+// 构建缓存相关函数
+
+static PyObject* py_build_cache_new(PyObject* self, PyObject* args) {
+    const char* cache_dir = ".cache";
+    int max_size = 1000000000;
+    
+    if (!PyArg_ParseTuple(args, "|si", &cache_dir, &max_size)) {
+        return nullptr;
+    }
+    
+    BuildCache* cache = new BuildCache(cache_dir, max_size);
+    return PyCapsule_New(cache, "BuildCache", [](PyObject* capsule) {
+        BuildCache* cache = static_cast<BuildCache*>(PyCapsule_GetPointer(capsule, "BuildCache"));
+        delete cache;
+    });
+}
+
+static PyObject* py_cache_build_result(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    const char* target;
+    const char* command;
+    PyObject* dependencies_obj;
+    const char* result;
+    
+    if (!PyArg_ParseTuple(args, "OsOs|s", &capsule, &target, &command, &dependencies_obj, &result)) {
+        return nullptr;
+    }
+    
+    BuildCache* cache = static_cast<BuildCache*>(PyCapsule_GetPointer(capsule, "BuildCache"));
+    if (cache == nullptr) {
+        return nullptr;
+    }
+    
+    // Convert Python list to C++ vector
+    std::vector<std::string> dependencies;
+    if (!PyList_Check(dependencies_obj)) {
+        PyErr_SetString(PyExc_TypeError, "dependencies must be a list");
+        return nullptr;
+    }
+    
+    Py_ssize_t len = PyList_Size(dependencies_obj);
+    for (Py_ssize_t i = 0; i < len; i++) {
+        PyObject* item = PyList_GetItem(dependencies_obj, i);
+        if (!PyUnicode_Check(item)) {
+            PyErr_SetString(PyExc_TypeError, "dependencies must contain strings");
+            return nullptr;
+        }
+        dependencies.push_back(PyUnicode_AsUTF8(item));
+    }
+    
+    bool success = cache->cache_build_result(target, command, dependencies, result ? result : "");
+    return PyBool_FromLong(success);
+}
+
+static PyObject* py_get_cached_build_result(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    const char* target;
+    const char* command;
+    PyObject* dependencies_obj;
+    
+    if (!PyArg_ParseTuple(args, "OsOs", &capsule, &target, &command, &dependencies_obj)) {
+        return nullptr;
+    }
+    
+    BuildCache* cache = static_cast<BuildCache*>(PyCapsule_GetPointer(capsule, "BuildCache"));
+    if (cache == nullptr) {
+        return nullptr;
+    }
+    
+    // Convert Python list to C++ vector
+    std::vector<std::string> dependencies;
+    if (!PyList_Check(dependencies_obj)) {
+        PyErr_SetString(PyExc_TypeError, "dependencies must be a list");
+        return nullptr;
+    }
+    
+    Py_ssize_t len = PyList_Size(dependencies_obj);
+    for (Py_ssize_t i = 0; i < len; i++) {
+        PyObject* item = PyList_GetItem(dependencies_obj, i);
+        if (!PyUnicode_Check(item)) {
+            PyErr_SetString(PyExc_TypeError, "dependencies must contain strings");
+            return nullptr;
+        }
+        dependencies.push_back(PyUnicode_AsUTF8(item));
+    }
+    
+    std::string cached_result = cache->get_cached_build_result(target, command, dependencies);
+    if (cached_result.empty()) {
+        Py_RETURN_NONE;
+    }
+    
+    return PyUnicode_FromString(cached_result.c_str());
+}
+
+static PyObject* py_needs_rebuild(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    const char* target;
+    const char* command;
+    PyObject* dependencies_obj;
+    
+    if (!PyArg_ParseTuple(args, "OsOs", &capsule, &target, &command, &dependencies_obj)) {
+        return nullptr;
+    }
+    
+    BuildCache* cache = static_cast<BuildCache*>(PyCapsule_GetPointer(capsule, "BuildCache"));
+    if (cache == nullptr) {
+        return nullptr;
+    }
+    
+    // Convert Python list to C++ vector
+    std::vector<std::string> dependencies;
+    if (!PyList_Check(dependencies_obj)) {
+        PyErr_SetString(PyExc_TypeError, "dependencies must be a list");
+        return nullptr;
+    }
+    
+    Py_ssize_t len = PyList_Size(dependencies_obj);
+    for (Py_ssize_t i = 0; i < len; i++) {
+        PyObject* item = PyList_GetItem(dependencies_obj, i);
+        if (!PyUnicode_Check(item)) {
+            PyErr_SetString(PyExc_TypeError, "dependencies must contain strings");
+            return nullptr;
+        }
+        dependencies.push_back(PyUnicode_AsUTF8(item));
+    }
+    
+    bool needs = cache->needs_rebuild(target, command, dependencies);
+    return PyBool_FromLong(needs);
+}
+
+// 模块方法定义
+static PyMethodDef PySmartCacheMethods[] = {
+    // LRUCache方法
+    {"lru_cache_new", py_lru_cache_new, METH_VARARGS, "Create a new LRUCache instance"},
+    {"lru_cache_put", py_lru_cache_put, METH_VARARGS, "Put a key-value pair into the LRUCache"},
+    {"lru_cache_get", py_lru_cache_get, METH_VARARGS, "Get a value from the LRUCache"},
+    
+    // BuildCache方法
+    {"build_cache_new", py_build_cache_new, METH_VARARGS, "Create a new BuildCache instance"},
+    {"cache_build_result", py_cache_build_result, METH_VARARGS, "Cache a build result"},
+    {"get_cached_build_result", py_get_cached_build_result, METH_VARARGS, "Get a cached build result"},
+    {"needs_rebuild", py_needs_rebuild, METH_VARARGS, "Check if a build needs to be redone"},
+    
+    {nullptr, nullptr, 0, nullptr}
+};
+
+// 模块定义
+static struct PyModuleDef pysmartcachemodule = {
+    PyModuleDef_HEAD_INIT,
+    "pysmartcache",
+    "Sikuwa Smart Cache Python Extension",
+    -1,
+    PySmartCacheMethods
+};
+
+// 模块初始化函数
+PyMODINIT_FUNC PyInit_pysmartcache(void) {
+    return PyModule_Create(&pysmartcachemodule);
+}