Mercurial > repos > jay > pdaug_basic_plots
comparison PDAUG_AA_Property_Based_Peptide_Generation/PDAUG_AA_Property_Based_Peptide_Generation.py @ 0:7d247e27ff11 draft
"planemo upload for repository https://github.com/jaidevjoshi83/pdaug commit a9bd83f6a1afa6338cb6e4358b63ebff5bed155e"
author | jay |
---|---|
date | Wed, 28 Oct 2020 01:52:18 +0000 |
parents | |
children | 738ee8fc0ede |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:7d247e27ff11 |
---|---|
1 from modlamp.sequences import * | |
2 import argparse, sys | |
3 import pandas as pd | |
4 import os | |
5 | |
6 def Random_seq(seq_num, lenmin_s, lenmax_s, S_proba, OutFasta): | |
7 | |
8 b = Random(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
9 b.generate_sequences(proba=float(S_proba)) | |
10 | |
11 OutPep = b.sequences | |
12 OutFasta = open(OutFasta, 'w') | |
13 | |
14 for i,O in enumerate(OutPep): | |
15 OutFasta.write(">sequence_"+str(i)+'\n') | |
16 OutFasta.write(O+'\n') | |
17 | |
18 def Helices_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
19 | |
20 h = Helices(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
21 h.generate_sequences() | |
22 | |
23 OutPep = h.sequences | |
24 OutFasta = open(OutFasta, 'w') | |
25 | |
26 for i,O in enumerate(OutPep): | |
27 OutFasta.write(">sequence_"+str(i)+'\n') | |
28 OutFasta.write(O+'\n') | |
29 | |
30 | |
31 def Kinked_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
32 | |
33 k = Kinked(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
34 k.generate_sequences() | |
35 | |
36 OutPep = k.sequences | |
37 OutFasta = open(OutFasta, 'w') | |
38 | |
39 for i,O in enumerate(OutPep): | |
40 OutFasta.write(">sequence_"+str(i)+'\n') | |
41 OutFasta.write(O+'\n') | |
42 | |
43 | |
44 def Oblique_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
45 | |
46 o = Oblique(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
47 o.generate_sequences() | |
48 o.sequences | |
49 | |
50 OutPep = o.sequences | |
51 OutFasta = open(OutFasta, 'w') | |
52 | |
53 for i,O in enumerate(OutPep): | |
54 OutFasta.write(">sequence_"+str(i)+'\n') | |
55 OutFasta.write(O+'\n') | |
56 | |
57 | |
58 def Centrosymmetric_seq(seq_num, lenmin_s, lenmax_s, symmetry_s, OutFasta): | |
59 | |
60 s = Centrosymmetric(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
61 s.generate_sequences(symmetry=symmetry_s) | |
62 | |
63 OutPep = s.sequences | |
64 OutFasta = open(OutFasta, 'w') | |
65 | |
66 for i,O in enumerate(OutPep): | |
67 OutFasta.write(">sequence_"+str(i)+'\n') | |
68 OutFasta.write(O+'\n') | |
69 | |
70 | |
71 def HelicesACP_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
72 | |
73 helACP = HelicesACP(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
74 helACP.generate_sequences() | |
75 | |
76 OutPep = helACP.sequences | |
77 OutFasta = open(OutFasta, 'w') | |
78 | |
79 for i,O in enumerate(OutPep): | |
80 OutFasta.write(">sequence_"+str(i)+'\n') | |
81 OutFasta.write(O+'\n') | |
82 | |
83 | |
84 def Hepahelices_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
85 | |
86 h = Hepahelices(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
87 h.generate_sequences() | |
88 | |
89 OutPep = h.sequences | |
90 OutFasta = open(OutFasta, 'w') | |
91 | |
92 for i,O in enumerate(OutPep): | |
93 OutFasta.write(">sequence_"+str(i)+'\n') | |
94 OutFasta.write(O+'\n') | |
95 | |
96 | |
97 def AMPngrams_seq(seq_num, lenmin_s, lenmax_s, OutFasta): | |
98 | |
99 s = AMPngrams(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
100 s.generate_sequences() | |
101 | |
102 OutPep = s.sequences | |
103 OutFasta = open(OutFasta, 'w') | |
104 | |
105 for i,O in enumerate(OutPep): | |
106 OutFasta.write(">sequence_"+str(i)+'\n') | |
107 OutFasta.write(O+'\n') | |
108 | |
109 def AmphipathicArc_seq(seq_num, lenmin_s, lenmax_s, gen_seq, hyd_gra, OutFasta): | |
110 | |
111 amphi_hel = AmphipathicArc(int(seq_num), int(lenmin_s),int(lenmax_s)) | |
112 amphi_hel.generate_sequences(int(gen_seq)) | |
113 OutFasta = open(OutFasta, 'w') | |
114 | |
115 if hyd_gra == 'true': | |
116 | |
117 amphi_hel.make_H_gradient() | |
118 OutPep = amphi_hel.sequences | |
119 | |
120 for i,O in enumerate(OutPep): | |
121 OutFasta.write(">sequence_"+str(i)+'\n') | |
122 OutFasta.write(O+'\n') | |
123 | |
124 elif hyd_gra == 'false': | |
125 | |
126 OutPep = amphi_hel.sequences | |
127 | |
128 for i,O in enumerate(OutPep): | |
129 OutFasta.write(">sequence_"+str(i)+'\n') | |
130 OutFasta.write(O+'\n') | |
131 | |
132 if __name__=='__main__': | |
133 | |
134 parser = argparse.ArgumentParser(description='Deployment tool') | |
135 subparsers = parser.add_subparsers() | |
136 | |
137 Ran = subparsers.add_parser('Random') | |
138 Ran.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
139 Ran.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
140 Ran.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
141 Ran.add_argument("-p","--S_proba", required=False, default='AMP', help="AA probability to be used to generate sequences,'rand', 'AMP', 'AMPnoCM', 'randnoCM', 'ACP'") | |
142 Ran.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
143 | |
144 Hal = subparsers.add_parser('Helices') | |
145 Hal.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
146 Hal.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
147 Hal.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
148 Hal.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
149 | |
150 Kin = subparsers.add_parser('Kinked') | |
151 Kin.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
152 Kin.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
153 Kin.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
154 Kin.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
155 | |
156 Obl = subparsers.add_parser('Oblique') | |
157 Obl.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
158 Obl.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
159 Obl.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
160 Obl.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
161 | |
162 Cen = subparsers.add_parser('Centrosymmetric') | |
163 Cen.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
164 Cen.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
165 Cen.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
166 Cen.add_argument("-S","--symmetry_s", required=False, default="asymmetric", help="symmetric,asymmetric") | |
167 Cen.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
168 | |
169 Hel = subparsers.add_parser('HelicesACP') | |
170 Hel.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
171 Hel.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
172 Hel.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
173 Hel.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
174 | |
175 Hep = subparsers.add_parser('Hepahelices') | |
176 Hep.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
177 Hep.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
178 Hep.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
179 Hep.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
180 | |
181 AMP = subparsers.add_parser('AMPngrams') | |
182 AMP.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
183 AMP.add_argument("-m","--n_min", required=False, default=3, help="minimum number of ngrams to take for sequence assembly") | |
184 AMP.add_argument("-M","--n_max", required=False, default=1, help="maximum number of ngrams to take for sequence assembly") | |
185 AMP.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
186 | |
187 Arc = subparsers.add_parser('AmphipathicArc') | |
188 Arc.add_argument("-s","--seq_num", required=True, default=None, help="number of sequences to be generated") | |
189 Arc.add_argument("-m","--lenmin_s", required=False, default=7, help="") | |
190 Arc.add_argument("-M","--lenmax_s", required=False, default=20, help="Len max") | |
191 Arc.add_argument("-a","--arcsize", help="Choose among 100, 140, 180, 220, 260, or choose mixed to generate a mixture") | |
192 Arc.add_argument("-y","--hyd_gra", default='False', help="Method to mutate the generated sequences to have a hydrophobic gradient by substituting the last third of the sequence amino acids to hydrophobic.") | |
193 Arc.add_argument("-O", "--OutFasta", required=True, default=None, help="Output Fasta") | |
194 | |
195 args = parser.parse_args() | |
196 | |
197 if sys.argv[1] == 'Random': | |
198 Random_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.S_proba, args.OutFasta) | |
199 elif sys.argv[1] == 'Helices': | |
200 Helices_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.OutFasta) | |
201 elif sys.argv[1] == 'Kinked': | |
202 Kinked_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.OutFasta) | |
203 elif sys.argv[1] == 'Oblique': | |
204 Oblique_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.OutFasta) | |
205 elif sys.argv[1] == 'Centrosymmetric': | |
206 Centrosymmetric_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.symmetry_s, args.OutFasta) | |
207 elif sys.argv[1] == 'HelicesACP': | |
208 HelicesACP_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.OutFasta) | |
209 elif sys.argv[1] == 'Hepahelices': | |
210 Hepahelices_seq(args.seq_num, args.lenmin_s, args.lenmax_s, args.OutFasta) | |
211 elif sys.argv[1] == 'AMPngrams': | |
212 AMPngrams_seq(args.seq_num, args.n_min, args.n_max, args.OutFasta) | |
213 elif sys.argv[1] == 'AmphipathicArc': | |
214 AmphipathicArc_seq(int(args.seq_num), int(args.lenmin_s), int(args.lenmax_s), int(args.arcsize), args.hyd_gra, args.OutFasta) | |
215 else: | |
216 print("You entered Wrong Values: ") |