lib_preprocess.cpp

orange源码 数据挖掘技术

      else
        valueList.push_back(value);
    }

    aMap->__ormap[var] = wvfilter;
    return 0;
  }

  if (var.is_derived_from(TStringVariable)) {
    TValueFilter_stringList *vfilter = mlnew TValueFilter_stringList(ILLEGAL_INT, var);
    PValueFilter wvfilter = vfilter;
    TStringList &values = vfilter->values.getReference();

    if (PyTuple_Check(pyvalue) || PyList_Check(pyvalue)) {
      PyObject *iterator = PyObject_GetIter(pyvalue);
      int i = 0;
      for(PyObject *item = PyIter_Next(iterator); item; item = PyIter_Next(iterator), i++) {
        if (!PyString_Check(item)) {
          PyErr_Format(PyExc_TypeError, "error at index %i, string expected", i);
          Py_DECREF(item);
          Py_DECREF(iterator);
          return -1;
        }
        Py_DECREF(item);
        values.push_back(PyString_AsString(item));
      }
      Py_DECREF(iterator);
    }
    else if (PyString_Check(pyvalue))
      values.push_back(PyString_AsString(pyvalue));
    else
      PyErr_Format(PyExc_TypeError, "string or a list of strings expected", -1);

    aMap->__ormap[var] = wvfilter;
    return 0;
  }
    
  PYERROR(PyExc_TypeError, "VariableFilterMap.__setitem__: unrecognized item type", -1);
}


template<>
int TMM_VariableFilterMap::_setitemlow(TVariableFilterMap *aMap, PyObject *pykey, PyObject *pyvalue)
{ PyTRY
    PVariable var;
    return TMM_VariableFilterMap::_keyFromPython(pykey, var) ? VariableFilterMap_setitemlow(aMap, var, pyvalue) : -1;
  PyCATCH_1
}


template<>
PyObject *TMM_VariableFilterMap::_setdefault(TPyOrange *self, PyObject *args)
{ PyObject *pykey;
  PyObject *deflt = Py_None;
  if (!PyArg_ParseTuple(args, "O|O:get", &pykey, &deflt))
    return PYNULL;

  PVariable var;
  if (!TMM_VariableFilterMap::_keyFromPython(pykey, var))
    return PYNULL;

  TVariableFilterMap *aMap = const_cast<TVariableFilterMap *>(PyOrange_AsVariableFilterMap(self).getUnwrappedPtr());
  
  iterator fi = aMap->find(var);
  if (fi==aMap->end()) {
    if (VariableFilterMap_setitemlow(aMap, var, deflt)<0)
      return PYNULL;

    // cannot return deflt here, since it is probably a string or tuple which was converted to ValueFilter
    // we just reinitialize fi and let the function finish :)
    fi = aMap->find(var);
  }

  return convertValueToPython((*fi).second);
}


PDistribution kaplanMeier(PExampleGenerator gen, const int &outcomeIndex, TValue &failValue, const int &timeIndex, const int &weightID);

PyObject *kaplanMeier(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(examples, outcome attribute, fail value, time attribute[, weightID]) -> survival curve")
{ PExampleGenerator egen;
  PyObject *outcomevar, *timevar;
  PyObject *pyfailvalue;
  TValue failvalue;
  int weightID = 0;
  if (!PyArg_ParseTuple(args, "O&OOOO&:kaplanMeier", pt_ExampleGenerator, &egen, &outcomevar, &pyfailvalue, &timevar, pt_weightByGen(egen), &weightID))

    return PYNULL;

  int outcomeIndex, timeIndex;
  if (outcomevar) {
    if (!varNumFromVarDom(outcomevar, egen->domain, outcomeIndex)) 
      PYERROR(PyExc_AttributeError, "outcome variable not found in domain", PYNULL);
  }
  else
    if (egen->domain->classVar)
      outcomeIndex = egen->domain->attributes->size();
    else
      PYERROR(PyExc_AttributeError, "'outcomeVar' not set and the domain is class-less", PYNULL);

  PVariable ovar = egen->domain->getVar(outcomeIndex);

  if (   !convertFromPython(pyfailvalue, failvalue, ovar)
      || failvalue.isSpecial()
      || (failvalue.varType != TValue::INTVAR))
    PYERROR(PyExc_AttributeError, "invalid value for failure", PYNULL);

  return WrapOrange(kaplanMeier(egen, outcomeIndex, failvalue, timeIndex, weightID));
}


// modified setitem to accept intervals/names of values
INITIALIZE_MAPMETHODS(TMM_VariableFilterMap, &PyOrVariable_Type, &PyOrValueFilter_Type, _orangeValueFromPython<PVariable>, _orangeValueFromPython<PValueFilter>, _orangeValueToPython<PVariable>, _orangeValueToPython<PValueFilter>)

PVariableFilterMap PVariableFilterMap_FromArguments(PyObject *arg) { return TMM_VariableFilterMap::P_FromArguments(arg); }
PyObject *VariableFilterMap_FromArguments(PyTypeObject *type, PyObject *arg) { return TMM_VariableFilterMap::_FromArguments(type, arg); }
PyObject *VariableFilterMap_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(items)") ALLOWS_EMPTY { return TMM_VariableFilterMap::_new(type, arg, kwds); }
PyObject *VariableFilterMap_str(TPyOrange *self) { return TMM_VariableFilterMap::_str(self); }
PyObject *VariableFilterMap_repr(TPyOrange *self) { return TMM_VariableFilterMap::_str(self); }
PyObject *VariableFilterMap_getitem(TPyOrange *self, PyObject *key) { return TMM_VariableFilterMap::_getitem(self, key); }
int       VariableFilterMap_setitem(TPyOrange *self, PyObject *key, PyObject *value) { return TMM_VariableFilterMap::_setitem(self, key, value); }
int       VariableFilterMap_len(TPyOrange *self) { return TMM_VariableFilterMap::_len(self); }
int       VariableFilterMap_contains(TPyOrange *self, PyObject *key) { return TMM_VariableFilterMap::_contains(self, key); }

PyObject *VariableFilterMap_has_key(TPyOrange *self, PyObject *key) PYARGS(METH_O, "(key) -> None") { return TMM_VariableFilterMap::_has_key(self, key); }
PyObject *VariableFilterMap_get(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(key[, default]) -> value") { return TMM_VariableFilterMap::_get(self, args); }
PyObject *VariableFilterMap_setdefault(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(key[, default]) -> value") { return TMM_VariableFilterMap::_setdefault(self, args); }
PyObject *VariableFilterMap_clear(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> None") { return TMM_VariableFilterMap::_clear(self); }
PyObject *VariableFilterMap_keys(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> keys") { return TMM_VariableFilterMap::_keys(self); }
PyObject *VariableFilterMap_values(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> values") { return TMM_VariableFilterMap::_values(self); }
PyObject *VariableFilterMap_items(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> items") { return TMM_VariableFilterMap::_items(self); }
PyObject *VariableFilterMap_update(TPyOrange *self, PyObject *args) PYARGS(METH_O, "(items) -> None") { return TMM_VariableFilterMap::_update(self, args); }
PyObject *VariableFilterMap__reduce__(TPyOrange *self, PyObject *) { return TMM_VariableFilterMap::_reduce(self); }


typedef MapMethods<PVariableFloatMap, TVariableFloatMap, PVariable, float> TMM_VariableFloatMap;
INITIALIZE_MAPMETHODS(TMM_VariableFloatMap, &PyOrVariable_Type, NULL, _orangeValueFromPython<PVariable>, _nonOrangeValueFromPython<float>, _orangeValueToPython<PVariable>, _nonOrangeValueToPython<float>);

PVariableFloatMap PVariableFloatMap_FromArguments(PyObject *arg) { return TMM_VariableFloatMap::P_FromArguments(arg); }
PyObject *VariableFloatMap_FromArguments(PyTypeObject *type, PyObject *arg) { return TMM_VariableFloatMap::_FromArguments(type, arg); }
PyObject *VariableFloatMap_new(PyTypeObject *type, PyObject *arg, PyObject *kwds) BASED_ON(Orange, "(items)") ALLOWS_EMPTY { return TMM_VariableFloatMap::_new(type, arg, kwds); } 
PyObject *VariableFloatMap_str(TPyOrange *self) { return TMM_VariableFloatMap::_str(self); }
PyObject *VariableFloatMap_repr(TPyOrange *self) { return TMM_VariableFloatMap::_str(self); }
PyObject *VariableFloatMap_getitem(TPyOrange *self, PyObject *key) { return TMM_VariableFloatMap::_getitem(self, key); }
int       VariableFloatMap_setitem(TPyOrange *self, PyObject *key, PyObject *value) { return TMM_VariableFloatMap::_setitem(self, key, value); }
int       VariableFloatMap_len(TPyOrange *self) { return TMM_VariableFloatMap::_len(self); }
int       VariableFloatMap_contains(TPyOrange *self, PyObject *key) { return TMM_VariableFloatMap::_contains(self, key); }

PyObject *VariableFloatMap_has_key(TPyOrange *self, PyObject *key) PYARGS(METH_O, "(key) -> None") { return TMM_VariableFloatMap::_has_key(self, key); }
PyObject *VariableFloatMap_get(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(key[, default]) -> value") { return TMM_VariableFloatMap::_get(self, args); }
PyObject *VariableFloatMap_setdefault(TPyOrange *self, PyObject *args) PYARGS(METH_VARARGS, "(key[, default]) -> value") { return TMM_VariableFloatMap::_setdefault(self, args); }
PyObject *VariableFloatMap_clear(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> None") { return TMM_VariableFloatMap::_clear(self); }
PyObject *VariableFloatMap_keys(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> keys") { return TMM_VariableFloatMap::_keys(self); }
PyObject *VariableFloatMap_values(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> values") { return TMM_VariableFloatMap::_values(self); }
PyObject *VariableFloatMap_items(TPyOrange *self, PyObject *args) PYARGS(METH_NOARGS, "() -> items") { return TMM_VariableFloatMap::_items(self); }
PyObject *VariableFloatMap_update(TPyOrange *self, PyObject *args) PYARGS(METH_O, "(items) -> None") { return TMM_VariableFloatMap::_update(self, args); }
PyObject *VariableFloatMap__reduce__(TPyOrange *self, PyObject *) { return TMM_VariableFloatMap::_reduce(self); }


/* ************ INDUCE ************ */

#include "induce.hpp"
#include "subsets.hpp"

ABSTRACT(FeatureInducer, Orange)

ABSTRACT(SubsetsGenerator, Orange)
C_NAMED(SubsetsGenerator_withRestrictions, SubsetsGenerator, "([subGenerator=])")

ABSTRACT(SubsetsGenerator_iterator, Orange)
C_NAMED(SubsetsGenerator_constant_iterator, SubsetsGenerator_iterator, "")
BASED_ON(SubsetsGenerator_constSize_iterator, SubsetsGenerator_iterator)
BASED_ON(SubsetsGenerator_minMaxSize_iterator, SubsetsGenerator_iterator)
C_NAMED(SubsetsGenerator_withRestrictions_iterator, SubsetsGenerator_iterator, "")

PyObject *FeatureInducer_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(examples, bound-attrs, new-name, weightID) -> (Variable, float)")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator egen;
    PyObject *boundList;
    char *name;
    int weight=0;
    if (!PyArg_ParseTuple(args, "O&Os|O&", pt_ExampleGenerator, &egen, &boundList, &name, pt_weightByGen(egen), &weight))
      PYERROR(PyExc_TypeError, "invalid arguments", PYNULL);

    TVarList boundset;
    if (!varListFromDomain(boundList, egen->domain, boundset))
      return PYNULL;

    float meas;
    PVariable newvar = SELF_AS(TFeatureInducer)(egen, boundset, name, meas, weight);
    return Py_BuildValue("Nf", WrapOrange(newvar), meas);
  PyCATCH
}




PVarList PVarList_FromArguments(PyObject *arg);

PVarList varListForReset(PyObject *vars)
{
  if (PyOrDomain_Check(vars))
    return PyOrange_AsDomain(vars)->attributes;

  PVarList variables = PVarList_FromArguments(vars);
  if (!variables)
    PYERROR(PyExc_TypeError, "SubsetsGenerator.reset: invalid arguments", NULL);

  return variables;
}


PyObject *SubsetsGenerator_reset(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "([[var0, var1, ...]]) -> int")
{ PyTRY
    PyObject *vars = PYNULL;
    if (!PyArg_ParseTuple(args, "|O:SubsetsGenerator.reset", &vars))
      return PYNULL;

    if (!vars)
      PYERROR(PyExc_TypeError, "SubsetsGenerator.reset does not reset the generator (as it used to)", false);

    PVarList varList = varListForReset(vars);
    if (!varList)
      return NULL;

    SELF_AS(TSubsetsGenerator).varList = varList;
    RETURN_NONE;
  PyCATCH
}


PyObject *SubsetsGenerator_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("([var0, var1] | domain |) -> SubsetsGenerator")
{ PyTRY
    NO_KEYWORDS

    if (args && PyTuple_Size(args) && !SubsetsGenerator_reset(self, args))
      return NULL;

    Py_INCREF(self);
    return self;
  PyCATCH
}


PyObject *SubsetsGenerator_iter(PyObject *self)
{ PyTRY
    return WrapOrange(SELF_AS(TSubsetsGenerator).call());
  PyCATCH
}


PyObject *SubsetsGenerator_iterator_iternext(PyObject *self)
{ PyTRY
    TVarList vl;
    if (!SELF_AS(TSubsetsGenerator_iterator).call(vl))
      return PYNULL;

    PyObject *list=PyTuple_New(vl.size());
    int i=0;
    ITERATE(TVarList, vi, vl)
      PyTuple_SetItem(list, i++, WrapOrange(*vi));
    return list;
  PyCATCH
}


PyObject *SubsetsGenerator_iterator_next(PyObject *self)
{ Py_INCREF(self);
  return self;
}


void packCounter(const TCounter &cnt, TCharBuffer &buf)
{
  buf.writeInt(cnt.limit);
  buf.writeInt(cnt.size());
  const_ITERATE(TCounter, ci, cnt)
    buf.writeInt(*ci);
}


void unpackCounter(TCharBuffer &buf, TCounter &cnt)
{
  cnt.limit = buf.readInt();

  int size = buf.readInt();
  cnt.resize(size);
  for(TCounter::iterator ci(cnt.begin()); size--; *ci++ = buf.readInt());
}


PyObject *SubsetsGenerator_constSize_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(SubsetsGenerator, "(size)") ALLOWS_EMPTY
{ PyTRY
    int B = 2;
    PyObject *varlist = NULL;
    PyObject *res;

    // This is for compatibility ...
    if (PyArg_ParseTuple(args, "|iO:SubsetsGenerator_constSize.__new__", &B, &varlist)) {
      TSubsetsGenerator *ssg = mlnew TSubsetsGenerator_constSize(B);
      res = WrapNewOrange(ssg, type);
      if (varlist) {
        SubsetsGenerator_reset(res, varlist);
      }
      return res;
    }
    PyErr_Clear();

    // ... and this if for real
    if (!PyArg_ParseTuple(args, "|O:SubsetsGenerator_constSize.__new__", &varlist))
      return PYNULL;

    TSubsetsGenerator *gen = mlnew TSubsetsGenerator_constSize(B);
    if (varlist && !(gen->varList = varListForReset(varlist))) {
      delete gen;
      return NULL;
    }

    return WrapNewOrange(gen, type);
  PyCATCH
}

PyObject *SubsetsGenerator_constSize_iterator__reduce__(PyObject *self)
{
  PyTRY
    CAST_TO(TSubsetsGenerator_constSize_iterator, gen);

    TCharBuffer buf((gen->counter.size() + 4) * sizeof(int));
    packCounter(gen->counter, buf);
    buf.writeChar(gen->moreToCome ? 1 : 0);

    return Py_BuildValue("O(OOs#)N", getExportedFunction("__pickleLoaderSubsetsGeneratorConstSizeIterator"),
                                    self->ob_type,
                                    WrapOrange(gen->varList),
                                    buf.buf, buf.length(),
                                    packOrangeDictionary(self));
 PyCATCH
}


PyObject *__pickleLoaderSubsetsGeneratorConstSizeIterator(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, packed_counter)")
{
  PyTRY
    PyTypeObject *type;
    PVarList varList;
    char *pbuf;
    int bufSize;
    if (!PyArg_ParseTuple(args, "OOs#:__pickleLoaderSubsetsGenerator_constSizeIterator", &type, ccn_VarList, &varList, &pbuf, &bufSize))
      return NULL;

    TCharBuffer buf(pbuf);

    TSubsetsGenerator_constSize_iterator *gen = new TSubsetsGenerator_constSize_iterator(varList, buf.readInt());
    unpackCounter(buf, gen->counter);
    gen->moreToCome = buf.readChar() != 0;

    return WrapNewOrange(gen, type);
  PyCATCH
}



PyObject *SubsetsGenerator_minMaxSize_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(SubsetsGenerator, "([min=, max=][, varList=])") ALLOWS_EMPTY
{ PyTRY
    int min = 2, max = 3;
    PyObject *varlist = NULL;

    // This is for compatibility ...
    if (args && PyArg_ParseTuple(args, "|iiO", &min, &max, &varlist)) {
      PyObject *res = WrapNewOrange(mlnew TSubsetsGenerator_minMaxSize(min, max), type);
      if (varlist)
        SubsetsGenerator_reset(res, varlist);

      return res;
    }
    PyErr_Clear();

    // ... and this if for real
    if (!PyArg_ParseTuple(args, "|O:SubsetsGenerator_minMaxSize.__new__", &varlist))
      return PYNULL;
      
    TSubsetsGenerator *gen = mlnew TSubsetsGenerator_minMaxSize(min, max);
    if (varlist && !(gen->varList = varListForReset(varlist))) {