Python 3 C-API IO y Ejecución del archivo

Question

Estoy teniendo serios problemas para conseguir una C motor de Python 2 ++ basado en el trabajo en python3. Sé que toda la pila IO ha cambiado, pero todo lo que parece que intenta simplemente termina en fracaso. A continuación se muestra el código de pre-(python2) y de código postal (python3). Estoy esperando que alguien puede ayudar a averiguar lo que estoy haciendo wrong.I También estoy usando boost::python para controlar las referencias.

El programa se supone que debe cargar un objeto de Python en la memoria a través de un mapa y luego en el uso de la función de ejecución que luego encuentra el archivo cargado en la memoria y lo ejecuta. Basé mi código de ejemplo desde el gestor de Delta3D pitón, donde se cargan en un archivo y se ejecutan inmediatamente. No he visto nada equivalente en python3.

---

Código python2 Empieza aquí:

    // what this does is first calls the Python C-API to load the file, then pass the returned
    // PyObject* into handle, which takes reference and sets it as a boost::python::object.
    // this takes care of all future referencing and dereferencing.
    try{
        bp::object file_object(bp::handle<>(PyFile_FromString(fullPath(filename), "r" )));
        loaded_files_.insert(std::make_pair(std::string(fullPath(filename)), file_object));
    }
    catch(...)
    {
        getExceptionFromPy();
    }

A continuación me carga el archivo de la std :: mapa y tratar de ejecutarlo:

    bp::object loaded_file = getLoadedFile(filename);
    try
    {
        PyRun_SimpleFile( PyFile_AsFile( loaded_file.ptr()), fullPath(filename) );
    }
    catch(...)
    {
        getExceptionFromPy();
    }

---

Código python3 Empieza aquí: Esto es lo que he basado en lo que va de algunas sugerencias aquí ... Así que la pregunta Carga:

        PyObject *ioMod, *opened_file, *fd_obj;

        ioMod = PyImport_ImportModule("io");
        opened_file = PyObject_CallMethod(ioMod, "open", "ss", fullPath(filename), "r");

        bp::handle<> h_open(opened_file);
        bp::object file_obj(h_open);
        loaded_files_.insert(std::make_pair(std::string(fullPath(filename)), file_obj));

Ejecutar:

    bp::object loaded_file = getLoadedFile(filename);
    int fd = PyObject_AsFileDescriptor(loaded_file.ptr());
    PyObject* fileObj = PyFile_FromFd(fd,fullPath(filename),"r",-1,"", "\n","", 0);

    FILE* f_open = _fdopen(fd,"r");

    PyRun_SimpleFile( f_open, fullPath(filename) );

Por último, el estado general del programa en este punto es el archivo se carga en tan TextIOWrapper y en la Carrera: sección de la FD que se devuelve siempre es 3 y por alguna razón _fdopen nunca puede abrir la FILE que significa que puedo 't hacer algo como PyRun_SimpleFile. El error en sí mismo es un ASSERTION de depuración en _fdopen. ¿Hay una mejor manera de hacer todo esto Realmente agradecería cualquier ayuda.

Si desea ver el programa completo de la versión python2 está en Github

Answer 1

Así que esta pregunta era bastante difícil de entender y lo siento, pero me encontré con mi viejo código no fue totalmente operativo que esperaba. Esto es lo que quería el código para hacerlo. Cargar el archivo de pitón en la memoria, almacenarlo en un mapa y luego en una fecha posterior que ejecute código en la memoria. He logrado esto un poco diferente de lo que esperaba, pero tiene mucho sentido ahora.

1. Abrir el archivo con ifstream, ver el siguiente código
2. Convertir el carbón en un impulso :: pitón :: str
3. Ejecutar el impulso :: :: str pitón con el impulso :: pitón :: exec
4. Beneficio ???

Paso 1)

vector<char> input;
ifstream file(fullPath(filename), ios::in);
if (!file.is_open())
{
    // set our error message here
    setCantFindFileError();
    input.push_back('\0');
    return input;
}

file >> std::noskipws;
copy(istream_iterator<char>(file), istream_iterator<char>(), back_inserter(input));
input.push_back('\n');
input.push_back('\0');

Paso 2)     pb :: file_str str (cadena (y de entrada [0]));     loaded_files_.insert (std :: make_pair (std :: string (fullPath (nombre del archivo)), file_str)); Paso 3)

bp::str loaded_file = getLoadedFile(filename);
// Retrieve the main module
bp::object main = bp::import("__main__");
// Retrieve the main module's namespace
bp::object global(main.attr("__dict__"));
bp::exec(loaded_file, global, global);

código completo se encuentra en github :