def test_get_linear_hydropathy(self):
testSeq = sequenceParameters.SequenceParameters('ASLPEALPSEPEASPEPASLEAPLSEPLASEASEEKEKEKEKEKEKEKEKEKEKALSPELASPELASEKEKASLEAPSELAPSELALSELAPSEAPSEAL')
self.assertEqual((np.array([ 0. , 0. , 0.49333333, 0.49333333, 0.59555556,
0.47555556, 0.49333333, 0.49333333, 0.41777778, 0.25555556,
0.33111111, 0.33111111, 0.37333333, 0.33111111, 0.37333333,
0.37333333, 0.37333333, 0.49333333, 0.49333333, 0.56888889,
0.49333333, 0.59555556, 0.49333333, 0.49333333, 0.41777778,
0.53777778, 0.49333333, 0.49333333, 0.49333333, 0.56888889,
0.46666667, 0.34888889, 0.28888889, 0.28 , 0.16222222,
0.09333333, 0.09333333, 0.08444444, 0.09333333, 0.08444444,
0.09333333, 0.08444444, 0.09333333, 0.08444444, 0.09333333,
0.08444444, 0.09333333, 0.08444444, 0.09333333, 0.08444444,
0.09333333, 0.08444444, 0.21111111, 0.37333333, 0.44222222,
0.48444444, 0.49333333, 0.53777778, 0.49333333, 0.49333333,
0.49333333, 0.49333333, 0.49333333, 0.49333333, 0.49333333,
0.45111111, 0.44222222, 0.28 , 0.15333333, 0.21111111,
0.27111111, 0.44222222, 0.44222222, 0.56888889, 0.49333333,
0.49333333, 0.33111111, 0.49333333, 0.49333333, 0.49333333,
0.49333333, 0.49333333, 0.49333333, 0.49333333, 0.61333333,
0.61333333, 0.61333333, 0.61333333, 0.61333333, 0.49333333,
0.49333333, 0.49333333, 0.44888889, 0.37333333, 0.39111111,
0.33111111, 0.44888889, 0.49333333, 0. , 0. ]) - testSeq.get_linear_hydropathy()[1] < 0.0001).all(), True)
def test_save_multiple_uverskyPlot2(self):
rseq2 = sequenceParameters.SequenceParameters(
testTools.generate_random_sequence(minLen=20, maxLen=500))
hy1 = self.rseq.get_uversky_hydropathy()
mnc1 = self.rseq.get_mean_net_charge()
hy2 = rseq2.get_uversky_hydropathy()
mnc2 = rseq2.get_mean_net_charge()
plots.save_multiple_uverskyPlot2([self.rseq, rseq2],
'tmpfiles/mult_UV.png', ['a', 'b'],
'TEST TITLE')
plots.save_multiple_uverskyPlot2([self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND.png',
['a', 'b'],
title='TEST TITLE',
legendOn=False)
plots.save_multiple_uverskyPlot2(
[self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND_xLim1.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=1)
plots.save_multiple_uverskyPlot2(
[self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND_xlim2.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2)
plots.save_multiple_uverskyPlot2(
[self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND_xlim2_ylim2.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2)
plots.save_multiple_uverskyPlot2(
[self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND_xlim2_ylim2_fs_20.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20)
plots.save_multiple_uverskyPlot2(
[self.rseq, rseq2],
'tmpfiles/mult_UV2_NO_LEGEND_xlim2_ylim2_fs_20.pdf', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20,
saveFormat='pdf')
def test_save_multiple_phasePlot2(self):
rseq2 = sequenceParameters.SequenceParameters(
testTools.generate_random_sequence(minLen=20, maxLen=500))
plots.save_multiple_phasePlot2(
[self.rseq, rseq2], 'tmpfiles/mult_PP', ['a', 'b'], 'TEST TITLE')
plots.save_multiple_phasePlot2(
[self.rseq, rseq2], 'tmpfiles/mult_PP_NO_LEGEND', ['a', 'b'], 'TEST TITLE', False)
plots.save_multiple_phasePlot2([self.rseq,
rseq2],
'tmpfiles/mult_PP_NO_LEGEND_xLim1.png',
['a',
'b'],
title='TEST TITLE',
legendOn=False,
xLim=1)
plots.save_multiple_phasePlot2([self.rseq,
rseq2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2.png',
['a',
'b'],
title='TEST TITLE',
legendOn=False,
xLim=2)
plots.save_multiple_phasePlot2([self.rseq,
rseq2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2.png',
['a',
'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2)
plots.save_multiple_phasePlot2([self.rseq,
rseq2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2_fs_20.png',
['a',
'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20)
plots.save_multiple_phasePlot2([self.rseq,
rseq2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2_fs_20.pdf',
['a',
'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20,
saveFormat='pdf')
def test_save_multiple_phasePlot(self):
rseq2 = sequenceParameters.SequenceParameters(
testTools.generate_random_sequence(minLen=20, maxLen=500))
fp1 = self.rseq.get_fraction_positive()
fn1 = self.rseq.get_fraction_negative()
fp2 = rseq2.get_fraction_positive()
fn2 = rseq2.get_fraction_negative()
plots.save_multiple_phasePlot([fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP', ['a', 'b'],
'TEST TITLE')
plots.save_multiple_phasePlot([fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND.png',
['a', 'b'],
title='TEST TITLE',
legendOn=False)
plots.save_multiple_phasePlot([fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND_xLim1.png',
['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=1)
plots.save_multiple_phasePlot([fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2.png',
['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2)
plots.save_multiple_phasePlot(
[fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2)
plots.save_multiple_phasePlot(
[fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2_fs_20.png', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20)
plots.save_multiple_phasePlot(
[fp1, fp2], [fn1, fn2],
'tmpfiles/mult_PP_NO_LEGEND_xlim2_ylim2_fs_20.pdf', ['a', 'b'],
title='TEST TITLE',
legendOn=False,
xLim=2,
yLim=2,
fontSize=20,
saveFormat='pdf')
def test_get_linear_FCR(self):
testSeq = sequenceParameters.SequenceParameters('ASLPEALPSEPEASPEPASLEAPLSEPLASEASEEKEKEKEKEKEKEKEKEKEKALSPELASPELASEKEKASLEAPSELAPSELALSELAPSEAPSEAL')
self.assertEqual((np.array([ 0. , 0. , 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.4,
0.4, 0.2, 0.4, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2,
0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.6,
0.6, 0.8, 1. , 1. , 1. , 1. , 1. , 1. , 1. , 1. , 1. ,
1. , 1. , 1. , 1. , 1. , 1. , 1. , 1. , 0.8, 0.6, 0.4,
0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4,
0.4, 0.6, 0.8, 0.8, 0.6, 0.4, 0.4, 0.2, 0.2, 0.2, 0.4,
0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2,
0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.2, 0.2, 0. ,
0. ]) == testSeq.get_linear_FCR()[1]).all(), True)
def test_phaseDiagramDefinitions(self):
base = "EKEKEKEKEKEKEK"
sequences = []
phaseplotreg = []
for extender in ['E', 'K', 'G', 'GK', 'GE']:
for i in range(0, 50):
if i > 20:
if i % 2 == 0:
continue
if i > 30:
if i % 3 == 0:
continue
sequences.append(
sequenceParameters.SequenceParameters(base + extender * i))
phaseplotreg.append(
sequenceParameters.SequenceParameters(
base + extender * i).get_phasePlotRegion())
plots.save_multiple_phasePlot2(
sequences, 'tmpfiles/check_phasePlot_regions_match', phaseplotreg)
def setUp(self):
self.testObj = sequenceParameters.SequenceParameters(
"MDVFMKGLSKAKEGVVAAAEKTKQGVAEAAGKTKEGVLYVGSKTKEGVVHGVATVAEKTKEQVTNVGGAVVTGVTAVAQKTVEGAGSIAAATGFVKKDQLGKNEEGAPQEGILEDMPVDPDNEAYEMPSEEGYQDYEPEA")
def test_pathological_sequences(self):
# first our ability to reproduce the Das paper sequences
das = [
'EKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEKEK',
'EEEKKKEEEKKKEEEKKKEEEKKKEEEKKKEEEKKKEEEKKKEEEKKKEK',
'KEKKKEKKEEKKEEKEKEKEKEEKKKEEKEKEKEKKKEEKEKEEKKEEEE',
'KEKEEKEKKKEEEEKEKKKKEEKEKEKEKEEKKEEKKKKEEKEEKEKEKE',
'KEKEKKEEKEKKEEEKKEKEKEKKKEEKKKEEKEEKKEEKKKEEKEEEKE',
'EEEKKEKKEEKEEKKEKKEKEEEKKKEKEEKKEEEKKKEKEEEEKKKKEK',
'EEEEKKKKEEEEKKKKEEEEKKKKEEEEKKKKEEEEKKKKEEEEKKKKEK',
'KKKKEEEEKKKKEEEEKKKKEEEEKKKKEEEEKKKKEEEEKKKKEEEEKE',
'EEKKEEEKEKEKEEEEEKKEKKEKKEKKKEEKEKEKKKEKKKKEKEEEKE',
'EKKKKKKEEKKKEEEEEKKKEEEKKKEKKEEKEKEEKEKKEKKEEKEEEE',
'EKEKKKKKEEEKKEKEEEEKEEEEKKKKKEKEEEKEEKKEEKEKKKEEKK',
'EKKEEEEEEKEKKEEEEKEKEKKEKEEKEKKEKKKEKKEEEKEKKKKEKK',
'KEKKKEKEKKEKKKEEEKKKEEEKEKKKEEKKEKKEKKEEEEEEEKEEKE',
'EKKEKEEKEEEEKKKKKEEKEKKEKKKKEKKKKKEEEEEEKEEKEKEKEE',
'KKEKKEKKKEKKEKKEEEKEKEKKEKKKKEKEKKEEEEEEEEKEEKKEEE',
'EKEKEEKKKEEKKKKEKKEKEEKKEKEKEKKEEEEEEEEEKEKKEKKKKE',
'EKEKKKKKKEKEKKKKEKEKKEKKEKEEEKEEKEKEKKEEKKEEEEEEEE',
'KEEKKEEEEEEEKEEKKKKKEKKKEKKEEEKKKEEKKKEEEEEEKKKKEK',
'EEEEEKKKKKEEEEEKKKKKEEEEEKKKKKEEEEEKKKKKEEEEEKKKKK',
'EEKEEEEEEKEEEKEEKKEEEKEKKEKKEKEEKKEKKKKKKKKKKKKEEE',
'EEEEEEEEEKEKKKKKEKEEKKKKKKEKKEKKKKEKKEEEEEEKEEEKKK',
'KEEEEKEEKEEKKKKEKEEKEKKKKKKKKKKKKEKKEEEEEEEEKEKEEE',
'EEEEEKEEEEEEEEEEEKEEKEKKKKKKEKKKKKKKEKEKKKKEKKEEKK',
'EEEEKEEEEEKEEEEEEEEEEEEKKKEEKKKKKEKKKKKKKEKKKKKKKK',
'EEEEEEEEEEEKEEEEKEEKEEKEKKKKKKKKKKKKKKKKKKEEKKEEKE',
'KEEEEEEEKEEKEEEEEEEEEKEEEEKEEKKKKKKKKKKKKKKKKKKKKE',
'KKEKKKEKKEEEEEEEEEEEEEEEEEEEEKEEKKKKKKKKKKKKKKKEKK',
'EKKKKKKKKKKKKKKKKKKKKKEEEEEEEEEEEEEEEEEEKKEEEEEKEK',
'KEEEEKEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKK',
'EEEEEEEEEEEEEEEEEEEEEEEEEKKKKKKKKKKKKKKKKKKKKKKKKK']
das_kappa = [
0.000880589547008,
0.00256304234944,
0.0138226351796,
0.024499790002,
0.0139736279003,
0.0272607247241,
0.0450342748224,
0.0450342748224,
0.0624156640006,
0.083437842179,
0.0840461196368,
0.0864189374177,
0.0951073474213,
0.131060316051,
0.135374506326,
0.145853296103,
0.16433443748,
0.167720875959,
0.194104529923,
0.27210316789,
0.273742292347,
0.321856766152,
0.354595821897,
0.445561294563,
0.528308824282,
0.610154441657,
0.672910640197,
0.766654273884,
0.876364376789,
1.0]
count = 0
for i in das:
a = sequenceParameters.SequenceParameters(i)
self.assertEqual(
round(
das_kappa[count], 12), round(
a.get_kappa(), 12))
count = count + 1
Pathoseqs = [
'EEEEEEEEEEEDDEEEEGDD',
'EEEDDEEEEDESSSSGGGEE',
'EEEEEFGLDEEDEDEDEDEE',
'EEEEEDEDEDEDEDEAGSEL',
'EEEDDEDDEDSEEDSEDDED',
'EEDAECIDDDEEDEEDEEED',
'EDDEEAEEEEEEEEEEEDED',
'DGEDEDDEDDDDDDDDDDDD',
'SEEEEEEKEEEEEEEEEEEE',
'EEKEEEEEEEEEEEEEEEDE',
'EDSNEDEEEDDEEEDEEDDE',
'DEEEDDEEEDEEDDEDDESD',
'DDDDDDDSDDQGDEDDEDEE',
'EEDDEEEEEEEEEEEEELTE',
'EEDEEDEEEEESESSDSEEE',
'EGADMEEEEEEEEEEEEEEE',
'DDDDEDDDEDDDDEDLRTDS',
'EEEEEEEEEEEEETGSNSEE',
'SDSDSEEEDDEEEDDEDEDD',
'EGLGVQGAEEEEEEEEEEEE',
'ESEEGQEDEDEEDEEDEDEE',
'DEDEEEEDEEEDEEDKDADS',
'EEEKEDEEEEEEEEEEEEEE',
'DEEEEEEEEEEEEEEEVTEV',
'EPIEEEEEEEEEEEEEEEED',
'EEEEEEEEEEEEEEDQDMDA',
'ESDEEEEEEEEEEEEEDDDD',
'EEEEEEEEEEEDDDDDKGDG',
'DDEDDEESDEEEEEEEEEEE',
'EEEEEEEEEEEEATDSEEEE',
'QEEGGEEEEEEEEEEEEEEE',
'EEEEEDEEEEEEEDSIVDDA',
'EEEEDEEEEGEEGEEDEEDE',
'EQLSEEEEEEEEEEEEEEEE',
'EEEEEEEEEEEAEEEEEEED',
'DEEEDEEEEEEDEEALLEDE',
'EEEEEEEELPEDDEEEEEEE',
'EEELPEDDEEEEEEEEEDDD',
'EEEDDEDEEEEEEEEEGDGE',
'ESSEEEEEEEDEEEEEEEEE',
'EEEEEEEEEEEEEEEEEGEE',
'EENDDQEEEEEDEDDEDDEE',
'EDEEEEDDDDDDEGEDDGEE',
'PLDKACAEDDDEEDEEEEEE',
'DDEDDDEAEDNDEDEDDDEE',
'DEDDDEDGEDVEDEEEEEEE',
'EDGEDVEDEEEEEEEEEEEE',
'EEEEEEEEEEEEEEEEAAPD',
'EEEEEEEEQEEEEEEEEEEE',
'EEDEDEDLEEEEEEEEEDDD',
'EEEEGGGQGEEEEEEEEDEE',
'EEEEEEEDDEDEDADISLEE',
'DDDDDDEEDDDEDDDDDDFD',
'DEEEDDDSEEDEEDDEDEDE',
'EEEEEEEEEEEEEDFEEEEE',
'EEEEEDEEEYFEEEEEEEEE',
'EEEEGELEEEEEEEDEEEEE',
'DSSSSSEDEEEEEEEEEDED',
'ELGYPREEDEEEEEDDEEEE',
'DLGEEEEEEEEEDEEEEEDD',
'EEDEEEEEDDDDDELEDEGE',
'EDEEEEEEEEEEEKEEEEEW',
'EEAEEEEEEDEEEEEEEEEE',
'DDDDDDDEEDGVFDDEDEEE',
'EEEEEEEEEAPVSVWDEEED',
'EDDDDDDDEDDDDEEENAED',
'EDEEEEEEEEEEDEDEDLEE',
'EEEDDDEDEDEEDDVSEGSE',
'EEEEEEEEEEEEEEEAEEEE',
'DEEEEEEEEEYDEEEEEEDD',
'DEDDEDEDEDEDEDEDEDKE',
'DEDEDEDEDEDEDKEEEEED',
'DASDNEEEEEEEEEEEEEEE',
'EEVDQQEEEEEEEEEEEEEE',
'EEEEEEEEEEEAAAAVALGE',
'EDEDDEDEDEEEEDDENGDS',
'ENEEDDEDEDDDEDDDEDED',
'DEDEDDDEDDDEDEDNESEG',
'EVDEDGEEEEEEEEEEEEEE',
'EEEEEEEEEEEEEEEEYEQD',
'EEEEEEDGHSEQEEEEEEEE',
'EEDDKEDDDDDEDDDDEEDE',
'DEEDEEEEEEEEEDDDDDTE',
'EMEESEEDEEEEDEEEEEED',
'EEDEEEEEEDEEESKAGGED',
'EEEEEAEEEEEEEEEEEEEE',
'EERNGLEEEEEDDEEDEEDD']
for i in Pathoseqs:
a = sequenceParameters.SequenceParameters(i)
self.assertGreaterEqual(1, a.get_kappa())
def test_general_coverage(self):
AAs = list("QWERTYIPASDFGHKLCVNM")
# generate 5 random sequences
# LENGTH BETWEEN 1 AND 150
random.seed()
seq_list = []
for i in range(0, 10):
L1 = random.randrange(200, 1000)
S1 = ""
for i in range(0, L1):
S1 = S1 + random.choice(AAs)
seq_list.append(S1)
pos = 0
print("")
# generate a list of 10 random sequences between
# length 100 and 1000
seq_list = testTools.generate_random_sequence_list(number=10, minLen=100, maxLen=1000)
# some edge cases...
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=3, maxLen=3))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=4, maxLen=4))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=5, maxLen=5))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=6, maxLen=6))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=7, maxLen=7))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=8, maxLen=8))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=9, maxLen=9))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=10, maxLen=10))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=11, maxLen=11))
seq_list.extend(testTools.generate_random_sequence_list(number=1, minLen=12, maxLen=12))
seq_list.append('EEEEEEEEEE')
seq_list.append('KKKKKKKKKK')
seq_list.append('EKEKEKEKEK')
seq_list.append('GGGGGGGGGG')
seq_list.append('EEEE')
seq_list.append('KKKK')
seq_list.append('EKEK')
seq_list.append('GGGG')
seq_list.append('EEEEE')
seq_list.append('KKKKK')
seq_list.append('EKEKE')
seq_list.append('GGGGG')
for i in seq_list:
print("")
print("Sequence " + str(pos))
print(i)
iSEQ = sequenceParameters.SequenceParameters(i)
iSEQ.get_FCR()
iSEQ.get_FCR(pH=2.0)
iSEQ.get_FCR(pH=13.0)
iSEQ.get_NCPR()
iSEQ.get_NCPR(pH=2.0)
iSEQ.get_NCPR(pH=13.0)
iSEQ.get_isoelectric_point()
iSEQ.get_countNeg()
iSEQ.get_countPos()
iSEQ.get_fraction_positive()
iSEQ.get_fraction_negative()
iSEQ.get_fraction_positive()
iSEQ.get_fraction_negative()
iSEQ.get_fraction_disorder_promoting()
iSEQ.get_fraction_expanding()
iSEQ.get_fraction_expanding(pH=2.0)
iSEQ.get_fraction_expanding(pH=14.0)
iSEQ.get_amino_acid_fractions()
iSEQ.get_kappa()
iSEQ.get_Omega()
iSEQ.get_Omega_sequence()
iSEQ.get_kappa_X(['A','K','P','G'])
iSEQ.get_kappa_X(['A','K','P','G'],['R','E','F','Y'])
iSEQ.get_mean_net_charge()
iSEQ.get_mean_net_charge(pH=2.0)
iSEQ.get_mean_net_charge(pH=14.0)
iSEQ.get_phasePlotRegion()
iSEQ.get_mean_hydropathy()
iSEQ.get_uversky_hydropathy()
iSEQ.get_HTMLColorString()
iSEQ.get_PPII_propensity()
iSEQ.get_PPII_propensity(mode='hilser')
iSEQ.get_PPII_propensity(mode='creamer')
iSEQ.get_PPII_propensity(mode='kallenbach')
#iSEQ.
iSEQ.get_delta()
iSEQ.get_deltaMax()
# check various reduced alphabets
for ABS in [2,3, 4,5,6,8,10,11,12,15,18,20]:
iSEQ.get_reduced_alphabet_sequence(ABS)
# actually check this...
self.assertEqual(iSEQ.get_length(), len(iSEQ))
# get linear vectors...
max_blobsize=len(i)
iSEQ.get_linear_FCR(min(5,max_blobsize))
iSEQ.get_linear_FCR(1)
iSEQ.get_linear_FCR(min(10, max_blobsize))
iSEQ.get_linear_NCPR(min(5,max_blobsize))
iSEQ.get_linear_NCPR(1)
iSEQ.get_linear_NCPR(min(10, max_blobsize))
iSEQ.get_linear_hydropathy(min(5,max_blobsize))
iSEQ.get_linear_hydropathy(1)
iSEQ.get_linear_hydropathy(min(10, max_blobsize))
# get complexity vectors (simple checks, more in depth in the
# complexity test file...)
for CT in ['WF','LC','LZW']:
for ABS in [2,5,10,20]:
for windowsize in [1,2,3]:
iSEQ.get_linear_complexity(complexityType=CT, alphabetSize=ABS, blobLen=windowsize)
psites = iSEQ.get_all_phosphorylatable_sites()
print("psites")
print(psites)
if len(psites) > 0:
# grab 3 sites randomly
sites = []
for i in range(0, 2):
sites.append(random.choice(psites))
iSEQ.set_phosphosites(sites)
iSEQ.get_kappa_after_phosphorylation()
iSEQ.get_phosphosequence()
iSEQ.get_full_phosphostatus_kappa_distribution()
iSEQ.clear_phosphosites()
# single
iSEQ.save_phaseDiagramPlot("tmpfiles/phase_test_S" + str(pos))
iSEQ.save_uverskyPlot("tmpfiles/uversky_test_S" + str(pos))
# try with a blobval
iSEQ.save_linearNCPR("tmpfiles/NCPR_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearFCR("tmpfiles/FCR_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearHydropathy(
"tmpfiles/Hydropathy_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearSigma("tmpfiles/sigma_test_S" + str(pos), min(5, max_blobsize))
# try with default
iSEQ.save_linearNCPR("tmpfiles/NCPR_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearFCR("tmpfiles/FCR_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearHydropathy("tmpfiles/Hydropathy_test_S" + str(pos), min(5, max_blobsize))
iSEQ.save_linearSigma("tmpfiles/sigma_test_S" + str(pos), min(5, max_blobsize))
pos = pos + 1
def setUp(self):
self.rseq = sequenceParameters.SequenceParameters(
testTools.generate_random_sequence(minLen=20, maxLen=500))
