def test_r_to_floats(self):
test_list = [1, 2, 3, 5, 6, None]
test_list_r = [1, 2, 3, 5, 6, ri.NARealType()]
input = ri.FloatSexpVector(test_list_r)
output = PredictionWorker._PredictionWorker__value_r_to_py(input, ri)
self.assertListEqualsSexp(test_list, output)
def pyobj2dataframe(valuelis, columnames=True, rownames=False):
"""
create rpy2-R data frame from table or list
to be used in R
"""
if isinstance(valuelis, robjects.vectors.DataFrame):
return valuelis
elif isinstance(valuelis, fhutils.Table):
pytab = fhutils.Table('data')
assert '-' not in valuelis.columnames, valuelis.columnames
pytab.columnames = valuelis.columnames
pytab.data = valuelis.data
else:
pytab = fhutils.Table('data')
if columnames: # if columnames provided extracted from the list
assert '-' not in valuelis[0], valuelis[0]
pytab.columnames = valuelis[0]
pytab.data = valuelis[1:]
else: # add arbitrary columnames
pytab.columnames = ['v' + str(i) for i in range(0, len(valuelis[0]))]
pytab.data = valuelis
tablist = []
for col in pytab.columnames:
coldata = pytab.getcolumn(col)
nv = []
for ele in coldata:
if isinstance(ele, list) or isinstance(ele, tuple):
ele = ele[0]
if isinstance(ele, int) or isinstance(ele, float):
nv.append(float(ele))
elif ele.isdigit():
nv.append(float(ele))
elif ele == 'NA':
nv.append(rinterface.NARealType())
else:
nv.append(fhutils.is_numeric(ele)) # try to convert into most likely type
if sum([1 for ele in nv if isinstance(ele, float) or isinstance(ele, int)]) < len(nv):
tablist.append((col, robjects.vectors.StrVector(nv)))
else:
tablist.append((col, robjects.vectors.FloatVector(nv)))
dataframe = robjects.DataFrame(rlc.OrdDict(tablist))
if rownames:
dfrmgen = robjects.r('data.frame')
dataframe = dfrmgen(dataframe, row_names=1)
return dataframe
def __value_py_to_r(value, ri):
"""Returns the R equivalent of a python value"""
val = value.value
if not isinstance(val, (list, tuple)):
# Is this an iterable ?
if hasattr(val,
'__iter__') and not isinstance(val, (str, unicode)):
val = [v for v in val]
else:
# In R scalar values are vectors with one element
# So here we put the scalar value into a list
val = [val]
na_value = None
if value.type == 'bool':
na_value = ri.NALogicalType()
elif value.type == 'byte':
na_value = ri.NAIntegerType(
) # I guess that's correct ? That should probably be tested though
elif value.type == 'float':
na_value = ri.NARealType()
elif value.type == 'int':
na_value = ri.NAIntegerType()
elif value.type == 'string':
na_value = ri.NACharacterType()
# Scan the elements to replace Nones by NA
val = [(na_value if v is None else v) for v in val]
if value.type == 'bool':
return ri.BoolSexpVector(val)
if value.type == 'byte':
return ri.ByteSexpVector(val)
if value.type == 'float':
return ri.FloatSexpVector(val)
if value.type == 'int':
return ri.IntSexpVector(val)
if value.type == 'string':
return ri.StrSexpVector(val)
raise PredictionValueTypeException(value.type)
def statoverview(valuelis, group='NA', filename='overview_data.txt', gformat='pdf'):
"""
overview statistics
R psych::describe which shows:
item name ,item number, nvalid, mean, sd,
median, mad, min, max, skew, kurtosis, se
"""
rconsole = rpystatinit()
rgeneralstats = rconsole("rgeneralstats")
dataframe = pyobj2dataframe(valuelis)
from rpy2.robjects.packages import importr
grdevices = importr('grDevices')
grdevices.pdf(file=fhutils.renamefilename(filename, suffix=gformat))
gdic = {'NA': rinterface.NARealType()}
group = gdic.get(group, group)
data = rgeneralstats(data=dataframe, group=group)
grdevices.dev_off()
out = open(filename, 'w')
out.write(str(data))
out.close()
def testNARealRepr(self):
na_float = ri.NARealType()
self.assertEqual("NA_real_", repr(na_float))
def testNARealInVector(self):
na_float = ri.NARealType()
x = ri.FloatSexpVector((1.1, na_float, 2.2))
self.assertTrue(x[1] is na_float)
self.assertEqual(1.1, x[0])
self.assertEqual(2.2, x[2])
def testNARealBinaryfunc(self):
na_real = ri.NARealType()
self.assertTrue((na_real + 2.0) is na_real)
def testNARealtoR(self):
na_real = ri.NARealType()
self.assertEqual(True, ri.baseenv["is.na"](na_real)[0])
def testRtoNAReal(self):
na_real = ri.NARealType()
r_na_real = evalr("NA_real_")[0]
self.assertTrue(r_na_real is na_real)
