wrapPyStock.cpp

Go to the documentation of this file.

#ifndef Python_for_stock
#define Python_for_stock
//#include <Python.h>
// eclipse fine with this, but python/C API doc says it is not good !
#include <python2.7/Python.h>
#endif

#include <cstdio>
#include <cstdlib>
#include <string>
#include <iostream>
#include <vector>

#include "Stock.h"
#include "ListDataStock.h"

// declare a c function keep as test
// to delete
int helloworld (int x)
{
    /*code that does something useful*/
    std::cout << "hello world last " << std::endl;
    return x;
}



// if all synchro, could read the header only, symbol must correspond, name only ?
// particlularly here, header is enough !!
// need a test boolean for reading in data_test
long int wrapLastCSVUpdate ( const char * symbol, bool btest ) {
    //here to call the real C++ LastCSVUpdate
    //use value by default, just check DAY and StockCSV
#ifdef DEBUG_WRAPPYSTOCK
    std::cout << "wrapLastCVSUpdate symbol: " << symbol << std::endl;
#endif

    // assign the name stock
    std::string tmp_symbol = std::string(symbol);

    time_t last_time_t=0;
    Utils::firstlast_dates dates = Utils::get_fldate_default();

    // if global to all function could be a variable of the module ?? how to do it ??
        if ( btest == true ) {
#ifdef DEBUG_WRAPPYSTOCK
                std::cout << "Set data_test mode" << std::endl;
#endif
                Utils::SetPathData( Utils::PATH_DATA_TEST );
        }

        // new version use only Read_HeaderCSV, static version
     try {
        Stock::Read_HeaderCSV_static( tmp_symbol, ETime::DAY, dates );
        last_time_t = dates.last;
    } catch (StockFileError &e ) {
        std::cout << "wrapPyStock::wrapLastCSVUpdate got exception " << std::endl;
        // what to do here ?? should create an exception in C for Python a wrapPyStockError ?
        return -1;
    }
    return (long int) last_time_t;
}

static PyObject * wrap_LastCSVUpdate(PyObject *, PyObject *args) //*self, *args
{
#ifdef DEBUG_WRAPPYSTOCK
        std::cout << "Entry wrapPyStock::wrap_LastCSVUpdate() " << std::endl;
#endif
    //std::string symbol;
    char *symbol;
    int itest = 0;
    bool btest = 0;
    long int result_date;

    // ":function" use for own error processing
    if (!PyArg_ParseTuple(args, "si:LastCVSUpdate",&symbol,&itest))
      return NULL;
    // got boolean from integer
    btest = itest;

#ifdef DEBUG_WRAPPYSTOCK
    std::cout << "symbol " << symbol << std::endl;
    std::cout << "btest" << btest << std::endl;
#endif

    result_date = wrapLastCSVUpdate( symbol, btest );

    return Py_BuildValue("i",result_date);
}

//
// called by wrap_UpdateCSV which makes translation between Python and C++ arguments and return
int wrapUpdateCSV (const char * symbol,std::vector<DataCSV> & new_csv,std::vector<SimpleData> & new_vol, bool btest )
{
#ifdef DEBUG_WRAPPYSTOCK
    std::cout << "\n\tEntry UpdateCVS in wrap: symbol " << symbol << std::endl;
    std::cout << "btest " << btest << std::endl;
#endif

    std::string tmp_symbol = std::string(symbol);

    if ( btest == true ) {
        std::cout << "Set data_test mode" << std::endl;
        Utils::SetPathData( Utils::PATH_DATA_TEST );
        }

    Stock * stock=new Stock( tmp_symbol );

    // create temporary list, but want to associate the vector already existing
    // important to set name StockCSV and Volume correctly, check at some points later
    ldata_candle *new_list_csv = new ldata_candle("StockCSV", ETime::DAY ,new_csv );
    ldata_volume *new_list_vol = new ldata_volume("Volume", ETime::DAY ,new_vol );

    // For ordering, yahoo return always no-chronological order
    new_list_csv->Order( EPChrono::NO_CHRONO);
    new_list_vol->Order( EPChrono::NO_CHRONO);

    //Problem of data member dates ! to delete later
    new_list_csv->SetDates();
    new_list_vol->SetDates();
#ifdef DEBUG_WRAPPYSTOCK
    new_list_csv->PrintData();
#endif



    // Assign first the Lists to the tmp stock
    stock->AddListDataToMap( ETime::DAY, new_list_csv);
    stock->AddListDataToMap( ETime::DAY, new_list_vol);
#ifdef DEBUG_WRAPPYSTOCK
    stock->PrintMapChrono();
#endif

    // Here for sure will create an other tmp_stock, could read first in this function !
    stock->SaveCSV( ETime::DAY, btest );

    // delete stock, and associated list
    delete stock;
    stock=0;

    return 0;
}

// wrapper, compiler say self not used ?? necessary ?? never modifed python object
static PyObject * wrap_hello(PyObject *, PyObject *args) //*self,args
{
    int x, result;
    if (!PyArg_ParseTuple(args, "i:hello",&x))
        return NULL;
    result = helloworld(x);
    return Py_BuildValue("i",result);
}



static PyObject * wrap_UpdateCSV(PyObject *, PyObject *args) //*self,*args
{
   char *symbol;
   // for tests, directory data_test
   bool btest = false;
   int itest = 0;

   int result;
   long int size;
   time_t date;
   double op,pl,mo,cl;
   double vol;
   //float vol;

   //create object for sending to stock wrapper
   std::vector<DataCSV> vec_csv_to_add;
   std::vector<SimpleData> vec_vol_to_add;

   //contain List data list of list
   PyObject *pyFullList;
   PyObject *pyListData;

   //Extract the first tuple
   // O means any object a list here
   //if (!PyArg_ParseTuple(args,"sO", &symbol, &pyFullList))
   // type int is important, not the order
   if (!PyArg_ParseTuple(args,"sOi", &symbol, &pyFullList, &itest))
      return NULL;

   // a priori not needed always borrowed references returned from PyArg_*
   //Py_XINCREF(pyFullList);
   std::cout << "parser works!!" << std::endl;

   //Check first
   std::cout << " symbol " << symbol << std::endl;
   if ( PyList_Check(pyFullList))
      std::cout << "Second argument is a list" << std::endl;
   // makes correct convertion int to bool ?
   btest = itest;
   std::cout << "btest " << btest << std::endl;
   std::cout << "itest " << itest << std::endl;


   size=PyList_GET_SIZE(pyFullList);
   std::cout << "size data pyFullList " << size << std::endl;

   //create temporary object for data, will be save in the vector
   DataCSV * data_csv = new DataCSV();
   SimpleData * data_vol = new SimpleData();

   for (int i=0;i<size;i++)
   {
           // Expects PySize_t
           // return a borrowed reference, nothing to care
           pyListData = PyList_GET_ITEM(pyFullList,i);

           //if ( PyList_Check(pyListData))
           //      std::cout << "pyListData is a list" << std::endl;
           date = (time_t) PyInt_AsLong(PyList_GET_ITEM(pyListData,0));
           op = PyFloat_AsDouble(PyList_GET_ITEM(pyListData,1));
           pl = PyFloat_AsDouble(PyList_GET_ITEM(pyListData,2));
           mo = PyFloat_AsDouble(PyList_GET_ITEM(pyListData,3));
           cl = PyFloat_AsDouble(PyList_GET_ITEM(pyListData,4));
           vol = PyFloat_AsDouble(PyList_GET_ITEM(pyListData,5));
           //std::cout << "date op " << date << " " << op << std::endl;

           //set data
           data_csv->SetData(date,op,pl,mo,cl);
           data_vol->SetData(date,vol);

           //copy to the vector, could make an object sur la pile pas besoin * and delete at the end
           //like this sure to be destroyed at the end of the function
           vec_csv_to_add.push_back(*data_csv);
           vec_vol_to_add.push_back(*data_vol);

           //clear the object, will see missing data
           // new function for this ?? no but overwritten anyway ?
           //data_csv->SetData(0,0.,0.,-1000.0,0.);
           //data_vol->SetData(0,0.);
        }

   //can delete tmp object
   delete data_csv;
   data_csv=0;
   delete data_vol;
   data_vol=0;

   //call wrapper in C and stock
   //std::cout << "in wrap_Update before wrapUpdateCSV" << std::endl;
   //std::cout << "value of csv " << vec_csv_to_add[0].GetOpen() << std::endl;
   //std::cout << "value of vol " << vec_vol_to_add[0].GetValue() << std::endl;
   
   result=wrapUpdateCSV(symbol, vec_csv_to_add, vec_vol_to_add, btest);

   //std::cout << "return from wrap_UpdateCSV, exit" << std::endl;
   return Py_BuildValue("i",result);
}

// note:
// A safe approach is to always use the generic operations (functions whose name begins with PyObject_, PyNumber_,
// PySequence_ or PyMapping_). These operations always increment the reference count of the object they return.
// This leaves the caller with the responsibility to call Py_DECREF() when they are done with the result;
// this soon becomes second nature.

// "the call mechanism guarantees to hold a reference to every argument for the duration of the call."
//   so that we do not need to care about incrementing/decrementing their use,
//   we are sure than at least one valid reference always exist.
static PyObject * wrap_SaveInst(PyObject *, PyObject *args)
{
#ifdef DEBUG_WRAPPYSTOCK
        std::cout << "Entry wrap_SaveInst " << std::endl;
#endif

        // local, temporary variable
        // only a  reference, should not attend to modify
        const char *symbol;
        PyObject *pyListData;
        // used for test directories
        bool btest;
        int itest;

        time_t date;
        float value,volume;
        // DataStock to fill with values
        SimpleData data_inst, data_volume;

        // function returns false AND and creates an exception, easy to catch from python caller, but from C++ ?
        // "Note that any Python object references which are provided to the caller are borrowed references;
        //   do not decrement their reference count!"
        if ( !PyArg_ParseTuple(args,"sOi", &symbol, &pyListData, &itest) ) {
                // only way to generate an error is with wrong string, other cases wrong type or missing do not cause error
                // this will throw: TypeError: function takes exactly 4 arguments (3 given)
                //if ( !PyArg_ParseTuple(args,"sOii", &symbol, &pyListData, "itest") ) {
                std::cout << "Error in PyArg_ParseTuple, return NULL" << std::endl;
                return NULL;
        }

        // convert to bool
        btest = itest;

        assert ( PyList_Check( pyListData ) == true );
        assert ( PyList_Size( pyListData ) == 3 );

#ifdef DEBUG_WRAPPYSTOCK
        std::cout << "\n parser argument" << std::endl;
        std::cout << "symbol " << symbol << std::endl;
        std::cout << "btest " << btest << std::endl;
        std::cout << "PyList_Check " << PyList_Check( pyListData )  << std::endl;
        std::cout << "length of pyListData " << PyList_Size( pyListData ) << std::endl;
#endif


   //date = (time_t) PyInt_AsLong( PyList_GET_ITEM(pyListData, 0) );
   date = (time_t) PyLong_AsLong( PyList_GET_ITEM(pyListData, 0) );
   value = PyFloat_AsDouble( PyList_GET_ITEM(pyListData, 1 ) );
   volume = PyFloat_AsDouble( PyList_GET_ITEM(pyListData, 2 ) );

   data_inst.SetData(date, value);
   data_volume.SetData(date, volume );
#ifdef DEBUG_WRAPPYSTOCK
   std::cout << "data_inst " << data_inst << std::endl;
   std::cout << "data_volume " << data_volume << std::endl;
#endif

   // assign PATH_DATA_TEST if python run in test_mode
   if ( btest == true ) {
        std::cout << "Set data_test mode" << std::endl;
        //Utils::SetPathData("/home/michael/workspace_kepler/ROOT_application/data_test");
        Utils::SetPathData( Utils::PATH_DATA_TEST );
   }
   // if test mode output (and input in this case ) in historical_tmp
   int status = Stock::UpdateCSV_Inst( symbol, data_inst, data_volume, ETime::INST, btest );
   if ( status != 0 ) {
           std::cout << "DictionaryStocks::SaveInst : No data append to the file " << std::endl;
           return Py_BuildValue("i",-1);
   }


   // correct return
   return Py_BuildValue("i",0);
}

//declare for error, not used yet
static PyObject *WrapError;

//define method, python add in dictionnary sys.module name wrap
//first argument called by python wrapPyStoc.LastCSVUpdate
//second actual C function called
static PyMethodDef WrapMethods[] = {
    {"hello",  wrap_hello, METH_VARARGS, "Execute a print hello."},
    {"LastCSVUpdate", wrap_LastCSVUpdate, METH_VARARGS, "Execute LastUpdate"},
    {"UpdateCSV", wrap_UpdateCSV, METH_VARARGS, "Execute UpdateCVS"},
    {"SaveInst", wrap_SaveInst, METH_VARARGS, "Execute SaveInst"},

    {NULL, NULL, 0, NULL} /* Sentinel */
};

// MACRO defines
// important init{name_module} when loading in python, anyway compile...
// work without, both python than C ?? same valgrind problems
PyMODINIT_FUNC
initwrapPyStock(void)
{
    PyObject *m;

    m = Py_InitModule("wrapPyStock", WrapMethods);
    if (m == NULL)
        return;

    // no more warning
    //char tmp_msg[] = "wrap.error";
    WrapError = PyErr_NewException((char *)"wrapPyStock.error", NULL, NULL);
    Py_INCREF(WrapError);
    PyModule_AddObject(m, "error", WrapError);
}