def testDoubleColumnames():
ex = None
try:
colnames = ["col0", "col0", "col1", "col1", "col2"]
Table(colnames, [] * 5, [] * 5)
except Exception, e:
ex = e.message
def testDynamicColumnAttributes():
t = Table(["a", "b", "c"], [str, int, int], ["%s", "%d", "%d"], [])
t.a
t.b
t.c
assert len(t.a.values) == 0
assert len(t.b.values) == 0
assert len(t.c.values) == 0
t.renameColumns(dict(a="aa"))
assert "a" not in t.getColNames()
assert "aa" in t.getColNames()
t.aa
try:
t.a
raise Exception("t.a should be deteted")
except:
pass
col = pickle.loads(pickle.dumps(t.aa))
assert len(col.values) == 0
t.dropColumns("aa")
assert "aa" not in t.getColNames()
try:
t.aa
raise Exception("t.aa should be deteted")
except:
pass
def setupTable():
names = "int long float str object array".split()
types = [
int,
long,
float,
str,
object,
np.ndarray,
]
formats = ["%3d", "%d", "%.3f", "%s", "%r", "'array(%r)' % o.shape"]
row1 = [1, 12323L, 1.0, "hi", {1: 1}, np.array((1, 2, 3))]
row2 = [2, 22323L, 2.0, "hi2", [
2,
3,
], np.array(((2, 3, 4), (1, 2, 3)))]
row3 = [
3, 32323L, 3.0, "hi3", (3, ),
np.array(((3, 3, 4, 5), (1, 2, 3, 4)))
]
rows = [row1, row2, row3]
t = Table(names, types, formats, rows, "testtabelle", meta=dict(why=42))
t = t.extractColumns("int", "float", "str")
t.addEnumeration()
t._name = "t"
t._print()
return t
def testRunnerTable():
with ExceptionTester():
Table(["a"], [np.float32], ["%f"], [[32.0]])
#build table
names = "int long float str object array".split()
types = [
int,
long,
float,
str,
object,
np.ndarray,
]
formats = ["%3d", "%d", "%.3f", "%s", "%r", "'array(%r)' % (o.shape,)"]
row1 = [1, 12323L, 1.0, "hi", {1: 1}, np.array((1, 2, 3))]
row2 = [2, 22323L, 2.0, "hi2", [
2,
3,
], np.array(((2, 3, 4), (1, 2, 3)))]
row3 = [
3, 32323L, 3.0, "hi3", (3, ),
np.array(((3, 3, 4, 5), (1, 2, 3, 4)))
]
rows = [row1, row2, row3]
t = Table(names, types, formats, rows, "testtabelle", meta=dict(why=42))
run(t, names, [row1, row2, row3])
# test pickle
dat = pickle.dumps(t)
t = pickle.loads(dat)
run(t, names, [row1, row2, row3])
ms.storeTable(t, u"temp_output/test.table")
try:
ms.storeTable(t, "temp_output/test.table")
assert False, "no exception thrown althoug file should exist!"
except:
pass
ms.storeTable(t, "temp_output/test.table", True)
t = ms.loadTable("temp_output/test.table")
run(t, names, [row1, row2, row3])
def testToOpenMSFeatureMap():
t = Table("mz rt".split(), [float, float], 2 * ["%.6f"])
fm = toOpenMSFeatureMap(t)
assert fm.size() == 0
t.addRow([1.0, 2.0])
fm = toOpenMSFeatureMap(t)
assert fm.size() == 1
f = fm[0]
assert f.getMZ() == 1.0 # == ok, as no digits after decimal point
assert f.getRT() == 2.0 # dito
def testIfThenElse():
t = Table(["a", "b", "c"], [str, int, int], ["%s", "%d", "%d"], [])
t.rows.append(["0", 1, 2])
t.rows.append([None, 2, 1])
t._print()
t.addColumn("x", (t.a.isNotNone()).thenElse(t.b, t.c))
assert t.getColNames() == ["a", "b", "c", "x"]
print
t._print()
t.addColumn("y", (t.a.isNotNone()).thenElse("ok", "not ok"))
t._print()
assert t.y.values == ["ok", "not ok"]
def isotopeDistributionTable(formula, R=None, fullC13=False, minp=0.01, **kw):
"""
generates Table for most common isotopes of molecule with given mass
*formula*.
If the resolution *R* is given, the measurement device is simulated, and
overlapping peaks may merge.
*fullC13=True* assumes that only C13 carbon is present in formula.
Further you can give a threshold *minp* for considering only isotope
peaks with an abundance above the value. Standard is *minp=0.01*.
If you have special elementary isotope abundances which differ from
the natural abundances, you can tell that like
``ms.isotopeDistributionTable("S4C4", C=dict(C13=0.5, C12=0.5))``
Examples:
.. pycon::
import ms !onlyoutput
# natural abundances:
tab = ms.isotopeDistributionTable("C3H7NO2")
tab.abundance /= tab.abundance.sum()
tab.print_()
# artifical abundances:
tab = ms.isotopeDistributionTable("C3H7NO2", C=dict(C13=0.5, C12=0.5))
tab.abundance /= tab.abundance.sum()
tab.print_()
\
"""
from libms.DataStructures.Table import Table
gen = _setupIsotopeDistributionGenerator(formula, R, fullC13, minp, **kw)
t = Table(["mf", "mass", "abundance"], [str, float, float],
["%s", "%.6f", "%.3f"], [])
for mass, abundance in gen.getCentroids():
t.addRow([formula, mass, abundance], False)
t.resetInternals()
return t
def testSomePredicates():
#build table
names = "int long float str object array".split()
types = [
int,
long,
float,
str,
object,
np.ndarray,
]
formats = ["%3d", "%d", "%.3f", "%s", "%r", "'array%r' % (o.shape,)"]
row1 = [1, 12323L, 1.0, "hi", {1: 1}, np.array((1, 2, 3))]
row2 = [2, 22323L, 2.0, "hi2", [
2,
3,
], np.array(((2, 3, 4), (1, 2, 3)))]
row3 = [
3, 32323L, 3.0, "hi3", (3, ),
np.array(((3, 3, 4, 5), (1, 2, 3, 4)))
]
rows = [row1, row2, row3]
t = Table(names, types, formats, rows, "testtabelle", meta=dict(why=42))
tn = t.filter((t.int + t.float).inRange(-1, 2))
assert len(tn) == 1
assert tn.getValue(tn.rows[0], "int") == 1
tn = t.filter((t.float + t.int).inRange(-1, 2))
assert len(tn) == 1
assert tn.getValue(tn.rows[0], "int") == 1
tn = t.filter(t.float.approxEqual(1.0, t.int / 10))
tn._print()
assert len(tn) == 1, len(tn)
assert tn.getValue(tn.rows[0], "int") == 1
def testIllegalRows():
try:
t = Table(["a", "b"], [float, float], ["%f", "%f"], [(1, 2)])
except Exception, e:
assert "not all rows are lists" in str(e), str(e)
def testDetectionOfUnallowdColumnNames():
ex = None
try:
Table(["__init__"], [int], ["%d"])
except Exception, e:
ex = e.message
def formulaTable(min_mass,
max_mass,
C=(0, None),
H=(0, None),
N=(0, None),
O=(0, None),
P=(0, None),
S=(0, None),
prune=True):
"""
This is a reduced Python version of HR2 formula generator,
see http://fiehnlab.ucdavis.edu/projects/Seven_Golden_Rules/Software/
This function generates a table containing molecular formulas consisting of
elements C, H, N, O, P and S having a mass in range
[**min_mass**, **max_mass**].
For each element one can provide an given count or an inclusive range of
atom counts considered in this process.
If **prune** is *True*, mass ratio rules and valence bond checks are used
to avoid unrealistic compounds in the table, else all formulas explaining
the given mass range are generated.
Putting some restrictions on atomcounts, eg **C=(0, 100)**, can speed up
the process tremendously.
"""
import mass
import math
import collections
from libms.DataStructures.Table import Table
if isinstance(C, collections.Sequence):
cmin, cmax = C
else:
cmin = cmax = C
if isinstance(H, collections.Sequence):
hmin, hmax = H
else:
hmin = hmax = H
if isinstance(N, collections.Sequence):
nmin, nmax = N
else:
nmin = nmax = N
if isinstance(O, collections.Sequence):
omin, omax = O
else:
omin = omax = O
if isinstance(P, collections.Sequence):
pmin, pmax = P
else:
pmin = pmax = P
if isinstance(S, collections.Sequence):
smin, smax = S
else:
smin = smax = S
cmax = math.ceil(max_mass / mass.C) if cmax is None else cmax
hmax = math.ceil(max_mass / mass.H) if hmax is None else hmax
nmax = math.ceil(max_mass / mass.N) if nmax is None else nmax
omax = math.ceil(max_mass / mass.O) if omax is None else omax
pmax = math.ceil(max_mass / mass.P) if pmax is None else pmax
smax = math.ceil(max_mass / mass.S) if smax is None else smax
# upper bounds for x/C ratios:
hcmax = 6 # 3
ncmax = 4 # 2
ocmax = 3 # 1.2
pcmax = 6 # 0.32
scmax = 2 # 0.65
# valence values for bound checks:
valh = -1
valc = +2
valn = 1
valo = 0
valp = 3
vals = 4
int_range = lambda a, b: xrange(int(a), int(b))
rows = []
for c in int_range(cmin, cmax + 1):
resmc_max = max_mass - c * mass.C
s1 = min(smax, math.floor(resmc_max / mass.S))
if prune:
s1 = min(s1, scmax * c)
for s in int_range(smin, s1 + 1):
resms_max = resmc_max - s * mass.S
p1 = min(pmax, math.floor(resms_max / mass.P))
if prune:
p1 = min(p1, pcmax * c)
for p in int_range(pmin, p1 + 1):
resmp_max = resms_max - p * mass.P
o1 = min(omax, math.floor(resmp_max / mass.O))
if prune:
o1 = min(o1, ocmax * c)
for o in int_range(omin, o1 + 1):
resmo_max = resmp_max - o * mass.O
n1 = min(nmax, math.floor(resmo_max / mass.N))
if prune:
n1 = min(n1, ncmax * c)
for n in int_range(nmin, n1 + 1):
resmn_max = resmo_max - n * mass.N
h1 = min(hmax, math.floor(resmn_max / mass.H))
if prune:
h1 = min(h1, hcmax * c)
for h in int_range(hmin, h1 + 1):
resmh_max = resmn_max - h * mass.H
if 0 <= resmh_max <= max_mass - min_mass:
bond = (2.0+c*valc+n*valn+o*valo+p*valp \
+s*vals+h*valh)/2.0
if not prune or (bond >= 0
and bond % 1 != 0.5):
mf = "C%d.H%d.N%d.O%d.P%d.S%d." \
% (c, h, n, o, p, s)
mf = mf.replace("C0.", ".")
mf = mf.replace("H0.", ".")
mf = mf.replace("N0.", ".")
mf = mf.replace("O0.", ".")
mf = mf.replace("P0.", ".")
mf = mf.replace("S0.", ".")
mf = mf.replace("C1.", "C.")
mf = mf.replace("H1.", "H.")
mf = mf.replace("N1.", "N.")
mf = mf.replace("O1.", "O.")
mf = mf.replace("P1.", "P.")
mf = mf.replace("S1.", "S.")
mf = mf.replace(".", "")
rows.append([mf, max_mass - resmh_max])
return Table(["mf", "m0"], [str, float], ["%s", "%.5f"], rows)
