[Bio] / FigKernelScripts / fig_net.pl Repository:
ViewVC logotype

Annotation of /FigKernelScripts/fig_net.pl

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.2 - (view) (download) (as text)

1 : efrank 1.1 # -*- perl -*-
2 :     use Carp;
3 :     use Data::Dumper;
4 :     use Time::HiRes qw(gettimeofday);
5 :    
6 :     use FIGnet;
7 :     use FIG;
8 : mkubal 1.2 use Blast;
9 : efrank 1.1
10 :     my($user);
11 :    
12 : mkubal 1.2 my $usage = "usage: fig_net $url [-echo] [-time] [command]";
13 : efrank 1.1
14 :     defined($url = shift @ARGV)
15 : mkubal 1.2 || die $usage;
16 : efrank 1.1
17 :     $figN = new FIGnet($url);
18 :     $fig = new FIG;
19 :    
20 :     $echo = 0;
21 :     $time_cmds = 0;
22 :     while ((@ARGV > 0) && ($ARGV[0] =~ /^-/))
23 :     {
24 :     $arg = shift @ARGV;
25 :     if ($arg =~ /^-time/i) { $time_cmds = 1 }
26 :     if ($arg =~ /^-echo/i) { $echo = 1 }
27 :     }
28 :    
29 : mkubal 1.2 my($t1,$t2,$i);
30 : efrank 1.1 if (@ARGV > 0) { $req = join( " ", @ARGV ); }
31 :     while ( (defined($req) && $req) || ($req = &get_req) )
32 :     {
33 :     if ($time_cmds)
34 :     {
35 :     $t1 = gettimeofday;
36 :     }
37 :    
38 : mkubal 1.2 if ($req =~ /^\s*DB\s*$/)
39 :     {
40 :     if ($figN->{_fig}) # if a local SEED
41 :     {
42 :     print "$FIG_Config::db\n\n";
43 :     }
44 :     else
45 :     {
46 :     my $url = $figN->{_url} . "/kernel.cgi?request=DB";
47 :     my @out = &FIGnet::get_url($url);
48 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
49 :     print $out[$i+1];
50 :     }
51 :     }
52 :     elsif ($req =~ /^\s*abbrev\s+(\S.*\S)\s*$/)
53 :     {
54 :     $genome_name = $1;
55 :     print &FIGnet::abbrev($genome_name),"\n";;
56 :     }
57 :     elsif ($req =~ /^\s*genomes(\s+(\S.*\S))?\s*$/)
58 : efrank 1.1 {
59 :     $pat = $2;
60 :     foreach $genome ($figN->genomes)
61 :     {
62 : mkubal 1.2 my $genus_species = $figN->genus_species($genome);
63 : efrank 1.1 if ((! $pat) || ($genus_species =~ /$pat/))
64 :     {
65 :     print join("\t",(&padded($genome,15),$genus_species)),"\n";
66 :     }
67 :     }
68 :     print "\n";
69 :     }
70 :     elsif ($req =~ /^\s*map_to_ecs\s+(\S+)\s*$/)
71 :     {
72 :     print join("\n",$figN->map_to_ecs($1)),"\n\n";
73 :     }
74 :     elsif ($req =~ /^\s*all_maps\s*$/)
75 :     {
76 :     @maps = $figN->all_maps;
77 :     foreach $map (@maps)
78 :     {
79 :     print "$map: ",$fig->map_name($map),"\n";
80 :     }
81 :     print "\n";
82 :     }
83 :     elsif ($req =~ /^\s*all_compounds\s*$/)
84 :     {
85 :     @compounds = $figN->all_compounds;
86 :     foreach $compound (@compounds)
87 :     {
88 :     my @tmp = $fig->names_of_compound($compound);
89 :     print "$compound: $tmp[0]\n";
90 :     }
91 :     print "\n";
92 :     }
93 :     elsif ($req =~ /^\s*all_reactions\s*$/)
94 :     {
95 :     @reactions = $figN->all_reactions;
96 :     foreach $reaction (@reactions)
97 :     {
98 :     $tmp = $fig->displayable_reaction($reaction);
99 :     print "$tmp\n";
100 :     }
101 :     print "\n";
102 :     }
103 :     elsif ($req =~ /^\s*reversible\s+(\S+)\s*$/)
104 :     {
105 :     $rid = $1;
106 :     $rev = $figN->reversible($rid) ? "reversible" : "not reversible";;
107 :     $displayable = $fig->displayable_reaction($rid);
108 :     print "$rev\n$displayable\n\n";
109 :     }
110 :     elsif ($req =~ /^\s*catalyzed_by\s+(\S+)\s*$/)
111 :     {
112 :     $rid = $1;
113 :     @ecs = $figN->catalyzed_by($rid);
114 :     $displayable = $fig->displayable_reaction($rid);
115 :     print "$displayable\n";
116 :     foreach $ec (@ecs)
117 :     {
118 :     $x = $fig->expand_ec($ec);
119 :     print "$x\n";
120 :     }
121 :     print "\n";
122 :     }
123 :     elsif ($req =~ /^\s*catalyzes\s+(\S+)\s*$/)
124 :     {
125 :     $ec = $1;
126 :     @rids = $figN->catalyzes($ec);
127 :     print $fig->expand_ec($ec),"\n";
128 :     foreach $rid (@rids)
129 :     {
130 :     $displayable = $fig->displayable_reaction($rid);
131 :     print "$displayable\n";
132 :     }
133 :     print "\n";
134 :     }
135 :     elsif ($req =~ /^\s*reaction2comp\s+(\S+)\s+(\d)\s*$/)
136 :     {
137 :     $rid = $1;
138 :     $which = $2;
139 :     @tmp = $figN->reaction2comp($rid,$which);
140 :     print &Dumper(\@tmp);
141 :     $displayable = $fig->displayable_reaction($rid);
142 :     print "$displayable\n\n";
143 :     }
144 :     elsif ($req =~ /^\s*names_of_compound\s+(\S+)\s*$/)
145 :     {
146 :     $cid = $1;
147 :     @names = $figN->names_of_compound($cid);
148 :     foreach $name (@names)
149 :     {
150 :     print "$name\n";
151 :     }
152 :     }
153 :     elsif ($req =~ /^\s*comp2react\s+(\S+)\s*$/)
154 :     {
155 :     $cid = $1;
156 :     @rids = $figN->comp2react($cid);
157 :     foreach $rid (@rids)
158 :     {
159 :     print $fig->displayable_reaction($rid),"\n";
160 :     }
161 :     }
162 :     elsif ($req =~ /^\s*names_of_compounds\s*$/)
163 :     {
164 :     foreach $x ($figN->names_of_compounds)
165 :     {
166 :     ($cid,$names) = @$x;
167 :     print "$cid\n";
168 :     foreach $name (@$names)
169 :     {
170 :     print "\t$name\n";
171 :     }
172 :     print "\n";
173 :     }
174 :     }
175 :     elsif ($req =~ /^\s*seqs_with_roles_in_genomes\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
176 :     {
177 :     $genomesF = $1;
178 :     $rolesF = $2;
179 :     $who = $3;
180 :     $genomes = [map { chop; $_ } `cat $genomesF`];
181 :     $roles = [map { chop; $_ } `cat $rolesF`];
182 :     print "\n";
183 :     }
184 : mkubal 1.2 elsif ($req =~ /^\s*feature_annotations\s+(\S+)\s*$/)
185 :     {
186 :     $fid = $1;
187 :     print "Annotations of $fid\n\n";
188 :     @annotations = $figN->feature_annotations($fid);
189 :     foreach $x (@annotations)
190 :     {
191 :     (undef,$ts,$who,$annotation) = @$x;
192 :     print "$ts\t$who\n$annotation\n============\n";
193 :     }
194 :     print "\n";
195 :     }
196 :     elsif ($req =~ /^\s*dna_seq\s+(\S+)\s+(\S+)\s*$/)
197 :     {
198 :     $seq = $figN->dna_seq($1,split(/,/,$2));
199 :     print "$seq\n\n";
200 :     }
201 :     elsif ($req =~ /^\s*all_protein_families\s*$/)
202 :     {
203 :     print "Fam.\tSize\n\n";
204 :     foreach $family ($figN->all_protein_families)
205 :     {
206 :     print "$family\t",$figN->sz_family($family),"\n";
207 :     }
208 :     print "\n";
209 :     }
210 :     #elsif ($req =~ /^\s*all_features\s+(\d+\.\d+)\s+(\S+)\s*$/)
211 :     #{
212 :     # @ids = sort { $figN->by_fig_id($a,$b) } $figN->all_features($1,$2);
213 :     # while (@ids > 0)
214 :     # {
215 :     # @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
216 :     # print join("\t",@tmp),"\n";
217 :     # }
218 :     # print "\n";
219 :     # }
220 :     elsif ($req =~ /^\s*all_sets\s+(\S+)\s+(\S+)\s*$/)
221 :     {
222 :     $relation = $1;
223 :     $set_name = $2;
224 :     print "Set\tSize\n\n";
225 :     foreach $set ($figN->all_sets($relation,$set_name))
226 :     {
227 :     print "$set\t",$figN->sz_set($set,$relation,$set_name),"\n";
228 :     }
229 :     print "\n";
230 :     }
231 :     elsif ($req =~ /^\s*catalyzed_by\s+(\S+)\s*$/)
232 :     {
233 :     $rid = $1;
234 :     @ecs = $fig->catalyzed_by($rid);
235 :     $displayable = $figN->displayable_reaction($rid);
236 :     print "$displayable\n";
237 :     foreach $ec (@ecs)
238 :     {
239 :     $x = $fig->expand_ec($ec);
240 :     print "$x\n";
241 :     }
242 :     print "\n";
243 :     }
244 :    
245 :     elsif ($req =~ /^\s*cgi_url\s*$/)
246 :     {
247 :     print $figN->cgi_url;
248 :    
249 :     }
250 :    
251 :     elsif ($req =~ /^\s*get_translation\s+(\S+)\s*$/)
252 :     {
253 :     $id = $1;
254 :     $seq = $figN->get_translation($id);
255 :     print "$seq\n";
256 :     print "\n";
257 :     }
258 :    
259 :     elsif ($req =~ /^\s*function_of\s+(\S+)(\s+(\S+))?\s*$/)
260 :     {
261 :     if ($2)
262 :     {
263 :     $extra = $2;
264 :     $all = ($extra =~ /all/i);
265 :     $tran = ($extra =~ /tran/i);
266 :     }
267 :     if ($all)
268 :     {
269 :     foreach $x ($figN->function_of($1))
270 :     {
271 :     ($who,$func) = @$x;
272 :     if ($tran) { $func = $figN->translate_function($func) }
273 :     print &padded($who,30)," $func\n";
274 :     }
275 :     }
276 :     else
277 :     {
278 :     $func = $figN->function_of($1);
279 :     if ($tran) { $func = $figN->translate_function($func) }
280 :     print "$func\n";
281 :     }
282 :     print "\n";
283 :     }
284 :     elsif ($req =~ /^\s*org_of\s+(\S+)\s*$/)
285 :     {
286 :     print $figN->org_of($1),"\n\n";
287 :     }
288 :    
289 :     elsif ($req =~ /^\s*blast\s+(\S+)\s*$/)
290 :     {
291 :     $id = $1;
292 :     $func = $figN->function_of($id);
293 :    
294 :     if ($sims = &Blast::blastp([[$id,$figN->get_translation($id)]],"$FIG_Config::global/nr","-e 1.0e-5",0,0))
295 :     {
296 :     $sims = $sims->{$id};
297 :    
298 :     print &padded($id,20),"\t",$sims->[0]->ln1."\t$func\n\n";
299 :     foreach $sim (@$sims)
300 :     {
301 :     $func = $figN->function_of($sim->id2);
302 :     $org = $figN->org_of($sim->id2);
303 :     print join("\t",(&padded($sim->id2,20),
304 :     $sim->ln2,
305 :     $sim->psc,
306 :     $sim->b1,
307 :     $sim->e1,
308 :     $sim->b2,
309 :     $sim->e2,
310 :     $org,
311 :     $func)),"\n";
312 :     }
313 :     }
314 :     print "\n";
315 :     }
316 :    
317 :     elsif ($req =~ /^\s*by_alias\s+(\S+)\s*$/)
318 :     {
319 :     $alias = $1;
320 :     print $figN->by_alias($alias);
321 :     }
322 :     elsif ($req =~ /^\s*by_fig_id\s+(\S+)\s+(\S+)\s*$/)
323 :     {
324 :     $feature_id_a = $1;
325 :     $feature_id_b = $2;
326 :     print $figN->by_fig_id($feature_id_a,$feature_id_b),"\n";
327 :     }
328 :     elsif ($req =~ /^\s*cas\s+(\S+)\s*$/)
329 :     {
330 :     $cid = $1;
331 :     $cas = $figN->cas($cid);
332 :     @names = $figN->names_of_compound($cid);
333 :     print "$cid\t$cas\t$names[0]\n\n";
334 :     }
335 :     elsif ($req =~ /^\s*cas_to_cid\s+(\S+)\s*$/)
336 :     {
337 :     $cas = $1;
338 :     $cid = $figN->cas_to_cid($cas);
339 :     print "$cid\n\n";
340 :     }
341 :     elsif ($req =~ /^\s*close_genes\s+(\S+)\s+(\S+)\s*$/)
342 :     {
343 :     $feature_id = $1;
344 :     $dist = $2;
345 :     print join(",",$figN->close_genes($feature_id,$dist)),"\n";
346 :     }
347 :     elsif ($req =~ /^\s*contig_ln\s+(\S+)\s+(\S+)\s*$/)
348 :     {
349 :     print $figN->contig_ln($1,$2),"\n\n";
350 :     }
351 :     elsif ($req =~ /^\s*coupling_and_evidence\s+(fig\|\d+\.\d+\.peg\.\d+)\s+(\d+)\s+(\S+)\s+(\S+)/)
352 :     {
353 :     $fid = $1;
354 :     $bound = $2;
355 :     $sim_cutoff = $3;
356 :     $coup_cutoff = $4;
357 :     @tmp = $figN->coupling_and_evidence($fid,$bound,$sim_cutoff,$coup_cutoff);
358 :     print &Dumper(\@tmp),"\n\n";
359 :     }
360 :    
361 :     elsif ($req =~ /^\s*crude_estimate_of_distance\s+(\S+)\s+(\S+)\s*$/)
362 :     {
363 :     print $figN->crude_estimate_of_distance($1,$2),"\n\n";
364 :     }
365 :     elsif ($req =~ /^\s*displayable_reaction\s+(\S+)\s*$/)
366 :     {
367 :     $rid = $1;
368 :     print $figN->displayable_reaction($rid),"\n";
369 :     }
370 :     elsif ($req =~ /^\s*ec_to_maps\s+(\S+)\s*$/)
371 :     {
372 :     print join("\n",$figN->ec_to_maps($1)),"\n\n";
373 :     }
374 :     elsif ($req =~ /^\s*map_name\s+(\S+)\s*$/)
375 :     {
376 :     print $figN->map_name($1),"\n\n";
377 :     }
378 :     elsif ($req =~ /^\s*verify_dir\s+(\S+)\s*$/)
379 :     {
380 :     $dir = $1;
381 :     $figN->verify_dir($dir);
382 :     print "$dir is now a directory\n";
383 :     }
384 :     elsif ($req =~ /^\s*ec_name\s+(\S+)\s*$/)
385 :     {
386 :     $ec= $1;
387 :     print $figN->ec_name($ec),"\n";
388 :     }
389 :     elsif ($req =~ /^\s*all_roles\s*$/)
390 :     {
391 :     my @tmp = $figN->all_roles;
392 :     print &Dumper(\@tmp);
393 :     }
394 :    
395 :     elsif ($req =~ /^\s*expand_ec\s+(\S+)\s*$/)
396 :     {
397 :     $ec = $1;
398 :     print $figN->expand_ec($ec),"\n";
399 :     }
400 :     elsif ($req =~ /^\s*clean_tmp\s*$/)
401 :     {
402 :     $figN->clean_tmp;
403 :     print "Cleaned $FIG_Config::temp\n";
404 :     }
405 :     elsif ($req =~ /^\s*ftype\s+(\S+)\s*$/)
406 :     {
407 :     $feature_id = $1;
408 :     print $figN->ftype($feature_id),"\n";;
409 :     }
410 :     elsif ($req =~ /^\s*genome_of\s+(\S+)\s*$/)
411 :     {
412 :     $feature_id = $1;
413 :     print $figN->genome_of($feature_id),"\n";
414 :     }
415 :     elsif ($req =~ /^\s*pegs_of\s+(\S+)\s*$/)
416 :     {
417 :     $genome = $1;
418 :     print join(",",$figN->pegs_of($genome)),"\n";
419 :     }
420 :     elsif ($req =~ /^\s*rnas_of\s+(\S+)\s*$/)
421 :     {
422 :     $genome = $1;
423 :     my @tmp = $figN->rnas_of($genome);
424 :     print &Dumper(\@tmp);
425 :     }
426 :     elsif ($req =~ /^\s*feature_aliases\s+(\S+)\s*$/)
427 :     {
428 :     $feature_id = $1;
429 :     print join(",",$figN->feature_aliases($feature_id)),"\n";
430 :     }
431 :     elsif ($req =~ /^\s*possibly_truncated\s+(\S+)\s*$/)
432 :     {
433 :     $feature_id = $1;
434 :     print $figN->possibly_truncated($feature_id),"\n";
435 :     }
436 :     elsif ($req =~ /^\s*is_real_feature\s+(\S+)\s*$/)
437 :     {
438 :     $feature_id = $1;
439 :     print $figN->is_real_feature($feature_id),"\n";
440 :     }
441 :     elsif ($req =~ /^\s*translatable\s+(\S+)\s*$/)
442 :     {
443 :     $prot_id = $1;
444 :     print $figN->translatable($prot_id),"\n";
445 :     }
446 :     elsif ($req =~ /^\s*maps_to_id\s+(\S+)\s*$/)
447 :     {
448 :     $id = $1;
449 :     print $figN->maps_to_id($id),"\n";
450 :     }
451 :     elsif ($req =~ /^\s*translated_function_of\s+(\S+)\s+(\S+)\s*$/)
452 :     {
453 :     $peg = $1;
454 :     $user = $2;
455 :     print $figN->translated_function_of($peg,$user),"\n";
456 :     }
457 :     elsif ($req =~ /^\s*translate_function\s+(\S.*\S)\s*$/)
458 :     {
459 :     $func = $1;
460 :     print $figN->translate_function($func),"\n";
461 :     }
462 :     elsif ($req =~ /^\s*hypo\s+(\S.*\S)\s*$/)
463 :     {
464 :     print $figN->hypo($1),"\n";
465 :     }
466 :     elsif ($req =~ /^\s*blastit\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
467 :     {
468 :     $peg = $1;
469 :     $seq = $2;
470 :     $db = $3;
471 :     $maxP = $4;
472 :     @tmp = $figN->blastit($peg,$seq,$db,$maxP);
473 :     print &Dumper(\@tmp);
474 :     }
475 :     elsif ($req =~ /^\s*related_by_func_sim\s+(\S+)\s+(\S+)\s*$/)
476 :     {
477 :     $peg = $1;
478 :     $user = $2;
479 :     print join(",",$figN->related_by_func_sim($peg,$user)),"\n";
480 :     }
481 :     elsif ($req =~ /^\s*epoch_to_readable\s*$/)
482 :     {
483 :     print $figN->epoch_to_readable(time);
484 :     }
485 :     elsif ($req =~ /^\s*search_index\s+(\S+)\s*$/)
486 :     {
487 :     $pattern = $1;
488 :     my @tmp = $figN->search_index($pattern);
489 :     print &Dumper(\@tmp);
490 :     }
491 :     elsif ($req =~ /^\s*sz_family\s+(\S+)\s*$/)
492 :     {
493 :     $family = $1;
494 :     print $figN->sz_family($family),"\n";
495 :     }
496 :     elsif ($req =~ /^\names_of_compound\s+(\S+)\s*$/)
497 :     {
498 :     my @tmp = $figN->names_of_compound($1);
499 :     print &Dumper(\@tmp);
500 :     }
501 :     elsif ($req =~ /^\s*reversible\s+(\S+)\s*$/)
502 :     {
503 :     $rid = $1;
504 :     print $figN->reversible($rid),"\n";
505 :     }
506 :     elsif ($req =~ /^\s*neighborhood_of_role\s+(\S+)\s*$/)
507 :     {
508 :     $role = $1;
509 :     my @tmp = $figN->neighborhood_of_role($role);
510 :     print &Dumper(\@tmp);
511 :     }
512 :     elsif ($req =~ /^\s*roles_of_function\s+(\S+)\s*$/)
513 :     {
514 :     $func = $1;
515 :     my @tmp = $figN->roles_of_function($func);
516 :     print &Dumper(\@tmp);
517 :     }
518 :     elsif ($req =~ /^\s*assign_function\s+(\S+)\s+(\S+)(\s+conf=(\S))?\s+(\S.*\S)\s*$/)
519 :     {
520 :     $peg = $1;
521 :     $user = $2;
522 :     $conf = $3 ? $4 : "";
523 :     $func = $5;
524 :     print $figN->assign_function($peg,$user,$func,$conf),"\n\n";
525 :     }
526 :     elsif ($req =~ /^\s*assign_functionF\s+(\S+)\s+(\S+)\s*$/)
527 :     {
528 :     $user = $1;
529 :     $file = $2;
530 :     if (open(TMP,"<$file"))
531 :     {
532 :     while (defined($_ = <TMP>))
533 :     {
534 :     chop;
535 :     ($peg,$func,$conf) = split(/\t/,$_);
536 :     if (! $conf) { $conf = "" }
537 :     if ($user =~ /master:(.*)/)
538 :     {
539 :     $userR = $1;
540 :     $funcO = $figN->function_of($peg);
541 :     if ($funcO ne $func)
542 :     {
543 :     $figN->assign_function($peg,"master",$func,$conf);
544 :     $figN->add_annotation($peg,$userR,"Set master function to\n$func\n");
545 :     }
546 :     }
547 :     else
548 :     {
549 :     $funcO = $figN->function_of($peg,$user);
550 :     if ($funcO ne $func)
551 :     {
552 :     $figN->assign_function($peg,$user,$func,$conf);
553 :     $figN->add_annotation($peg,$user,"Set function to\n$func\n");
554 :     }
555 :     }
556 :     }
557 :     close(TMP);
558 :     }
559 :     }
560 :    
561 :     elsif ($req =~ /^\s*largest_clusters\s+(\S+)\s+(\S+)\s*$/)
562 :     {
563 :     $file = $1;
564 :     $user = $2;
565 :     my @tmp = `cat $file`;
566 :     chop @tmp;;
567 :     my @tmp1 = $figN->largest_clusters(\@tmp,$user);
568 :     print &Dumper(\@tmp1);
569 :     }
570 :     elsif ($req =~ /^\s*unique_functions\s+(\S+)\s+(\S+)\s*$/)
571 :     {
572 :     $pegs = $1;
573 :     $user = $2;
574 :     my @tmp = $figN->unique_functions([split(/,/,$pegs)],$user);
575 :     print &Dumper(\@tmp);
576 :     }
577 :     elsif ($req =~ /^\s*extract_seq\s+(\S+)\s+(\S+)\s*$/)
578 :     {
579 :     $contigsF = $1;
580 :     $loc = $2;
581 :     $contigs = &load_contigs($contigsF);
582 :     print &Dumper(&FIG::extract_seq($contigs,$loc));
583 :     }
584 :     elsif ($req =~ /^\s*is_bacterial\s+(\S+)\s*$/)
585 :     {
586 :     $genome = $1;
587 :     print $figN->is_bacterial($genome),"\n";;
588 :     }
589 :     elsif ($req =~ /^\s*is_archaeal\s+(\S+)\s*$/)
590 :     {
591 :     $genome = $1;
592 :     print $figN->is_archaeal($genome),"\n";
593 :     }
594 :     elsif ($req =~ /^\s*is_prokaryotic\s+(\S+)\s*$/)
595 :     {
596 :     $genome = $1;
597 :     print $figN->is_prokaryotic($genome),"\n";
598 :     }
599 :     elsif ($req =~ /^\s*is_eukaryotic\s+(\S+)\s*$/)
600 :     {
601 :     $genome = $1;
602 :     print $figN->is_eukaryotic($genome),"\n";
603 :     }
604 :     elsif ($req =~ /^\s*sort_genomes_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
605 :     {
606 :     @list_of_genomes = split(/\s+/,$1);
607 :     print join(",",$figN->sort_genomes_by_taxonomy(@list_of_genomes)),"\n";
608 :     }
609 :     elsif ($req =~ /^\s*sort_fids_by_taxonomy\s+(\S+(\s+\S+)*)\s*$/)
610 :     {
611 :     @fids = split(/\s+/,$1);
612 :     print join(",",$figN->sort_fids_by_taxonomy(@fids)),"\n";
613 :     }
614 :     elsif ($req =~ /^\s*build_tree_of_complete\s+(\S+)\s*$/)
615 :     {
616 :     $min_for_label = $1;
617 :     print &Dumper($figN->build_tree_of_complete($min_for_label));
618 :     }
619 :     elsif ($req =~ /^\s*taxonomic_groups_of_complete\s+(\S+)\s*$/)
620 :     {
621 :     $min_for_labels = $1;
622 :     print &Dumper($figN->taxonomic_groups_of_complete($min_for_labels));
623 :     }
624 :     elsif ($req =~ /^\s*max\s+(((\d+)\s+)*\d+)\s*$/)
625 :     {
626 :     print $figN->max(split(/\s+/,$1)),"\n\n";
627 :     }
628 :     elsif ($req =~ /^\s*add_genome\s+((.*\/)?(\d+\.\d+))\s*$/)
629 :     {
630 :     $genomeF = $1;
631 :     $genome = $3;
632 :     if ((! -d "$FIG_Config::organisms/$genome") && ($figN->add_genome($genomeF)))
633 :     {
634 :     print "Added $genome\n";
635 :     }
636 :     else
637 :     {
638 :     print "Failed to add $genome from $genomeF\n";
639 :     }
640 :     }
641 :     elsif ($req =~ /^\s*delete_genomes\s+(\d.*\d)\s*$/)
642 :     {
643 :     $genomes = $1;
644 :     @genomes = split(/\s+/,$genomes);
645 :     if (@genomes > 0)
646 :     {
647 :     @bad_genomes = grep { ! -d "$FIG_Config::organisms/$_" } @genomes;
648 :     if (@bad_genomes > 0)
649 :     {
650 :     print "Bad Genomes: ",join(" ",@bad_genomes),"\n";
651 :     }
652 :     else
653 :     {
654 :     $figN->delete_genomes(\@genomes);
655 :     print "Completed deleting ",join(" ",@genomes),"\n";
656 :     }
657 :     }
658 :     }
659 :     elsif ($req =~ /^\s*min\s+(((\d+)\s+)*\d+)\s*$/)
660 :     {
661 :     print $figN->min(split(/\s+/,$1)),"\n\n";
662 :     }
663 :     elsif ($req =~ /^\s*between\s+(\d+)\s+(\d+)\s+(\d+)\s*$/)
664 :     {
665 :     print $figN->between($1,$2,$3),"\n\n";
666 :     }
667 :     elsif ($req =~ /^\s*merge_related_annotations\s+(\S.*\S)\s*$/)
668 :     {
669 :     $pegs = [split(/\s+/,$1)];
670 :     my @tmp = $figN->merged_related_annotations($pegs);
671 :     print &Dumper(\@tmp);
672 :     print "\n";
673 :     }
674 :     elsif ($req =~ /^\s*genus_species\s+(\d+\.\d+)\s*$/)
675 :     {
676 :     print $figN->genus_species($1),"\n\n";
677 :     }
678 :     elsif ($req =~ /^\s*genome_counts(\s+(complete))?/)
679 :     {
680 :     $counts = $figN->genome_counts($2);
681 :     print "$counts\n";
682 :     }
683 :     elsif ($req =~ /^\s*file2N\s+(\S+)\s*$/)
684 :     {
685 :     print $figN->file2N($1),"\n\n";
686 :     }
687 :     elsif ($req =~ /^\s*genome_version\s+(\S+)\s*$/)
688 :     {
689 :     $_ = defined($_ = $figN->genome_version($1)) ? $_ : "undefined";
690 :     print "$_\n\n";
691 :     }
692 :    
693 :     elsif ($req =~ /^\s*taxonomy_of\s+(\d+\.\d+)\s*$/)
694 :     {
695 :     print $figN->taxonomy_of($1),"\n\n";
696 :     }
697 :    
698 :     elsif ($req =~ /^\s*fast_coupling\s+(fig\|\d+\.\d+\.peg\.\d+)\s+(\d+)\s+(\S+)/)
699 :     {
700 :     $fid = $1;
701 :     $bound = $2;
702 :     $coup_cutoff = $3;
703 :     @tmp = $figN->fast_coupling($fid,$bound,$coup_cutoff);
704 :     print &Dumper(\@tmp),"\n\n";
705 :     }
706 :    
707 :     elsif ($req =~ /^\s*auto_assign\s+(fig\|\d+\.\d+\.peg\.\d+)(\s+(\S+))?\s*$/)
708 :     {
709 :     $fid = $1;
710 :     $seq = $3;
711 :     print $figN->auto_assign($fid,$seq),"\n\n";
712 :     }
713 :    
714 :     elsif ($req =~ /^\s*auto_assignG\s+(\S+)\s+(\S.*\S)\s*$/)
715 :     {
716 :     $user = $1;
717 :     @genomes = split(/\s+/,$2);
718 :     foreach $genome (@genomes)
719 :     {
720 :     if (-s "$FIG_Config::organisms/$genome/Features/peg/tbl")
721 :     {
722 :     print STDERR "making assignments for $genome\n";
723 :     system "cut -f1 $FIG_Config::organisms/$genome/Features/peg/tbl > tmp$$ ; fig auto_assignF $user tmp$$";
724 :     unlink("tmp$$");
725 :     }
726 :     }
727 :     print "\n";
728 :     }
729 :    
730 :     elsif (($req =~ /^\s*auto_assignF\s+(\S+)\s+(\S+)\s*$/) &&
731 :     ($file = $2) && (-s $file) &&
732 :     ($user = $1))
733 :     {
734 :     $n = 0;
735 :     foreach $assignment (`cut -f1 $file | auto_assign | make_calls`)
736 :     {
737 :     if ($assignment =~ /^(\S+)\t(\S[^\t]+\S)(\t(\S))?\s*$/)
738 :     {
739 :     $prot = $1;
740 :     $function = $2;
741 :     $conf = $4 ? $4 : "";
742 :     $n++;
743 :     if ($user =~ /master:(.*)/)
744 :     {
745 :     $userR = $1;
746 :     $figN->assign_function($prot,"master",$function,$conf);
747 :     if ($userR ne "none")
748 :     {
749 :     $figN->add_annotation($prot,$userR,"Set master function to\n$function\n");
750 :     }
751 :     }
752 :     else
753 :     {
754 :     $figN->assign_function($prot,$user,$function,$conf);
755 :     if ($user ne "none")
756 :     {
757 :     $figN->add_annotation($prot,$user,"Set function to\n$function\n");
758 :     }
759 :     }
760 :     }
761 :     }
762 :     close(TMP);
763 :     print STDERR "$n assignments made (all attributed to $user)\n";
764 :     }
765 :    
766 :     elsif ($req =~ /^\s*assignments_made\s+(\S+)\s+(\d{1,2}\/\d{1,2}\/\d{4})(\s+(\S.*\S))?\s*$/)
767 :     {
768 :     $who = $1;
769 :     $date = $2;
770 :     if ($3)
771 :     {
772 :     $genomes = [split(/\s+/,$4)];
773 :     }
774 :     else
775 :     {
776 :     $genomes = [$figN->genomes];
777 :     }
778 :    
779 :     foreach $assignment ($figN->assignments_made($genomes,$who,$date))
780 :     {
781 :     print join("\t",@$assignment),"\n";
782 :     }
783 :     }
784 :    
785 :     elsif ($req =~ /^\s*genes_in_region\s+(\d+\.\d+)\s+(\S+)\s+(\d+)\s+(\d+)\s*$/)
786 :     {
787 :     print &Dumper($figN->genes_in_region($1,$2,$3,$4)),"\n\n";
788 :     }
789 :     elsif ($req =~ /^\s*all_features\s+(\d+\.\d+)\s+(\S+)\s*$/)
790 :     {
791 :     @ids = sort { $figN->by_fig_id($a,$b) } $figN->all_features($1,$2);
792 :     while (@ids > 0)
793 :     {
794 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
795 :     print join("\t",@tmp),"\n";
796 :     }
797 :     print "\n";
798 :     }
799 :     elsif ($req =~ /^\s*function_of\s+(\S+)\s*(\S+)?\s*$/)
800 :     {
801 :     if ($2)
802 :     {
803 :     $extra = $2;
804 :     $all = ($extra =~ /all/i);
805 :     $tran = ($extra =~ /tran/i);
806 :     }
807 :     if ($all)
808 :     {
809 :     foreach $x ($figN->function_of($1))
810 :     {
811 :     ($who,$func) = @$x;
812 :     if ($tran) { $func = $figN->translate_function($func) }
813 :     print &padded($who,30)," $func\n";
814 :     }
815 :     }
816 :     else
817 :     {
818 :     $func = $figN->function_of($1);
819 :     if ($tran) { $func = $figN->translate_function($func) }
820 :     print "$func\n";
821 :     }
822 :     print "\n";
823 :     }
824 :     elsif ($req =~ /^\s*in_cluster_with\s+(\S+)\s*$/)
825 :     {
826 :     $peg = $1;
827 :     @pegs = $figN->in_cluster_with($peg);
828 :     $func = $figN->function_of($peg);
829 :     print "$peg\t$func\n\n";
830 :     foreach $peg (@pegs)
831 :     {
832 :     $func = $figN->function_of($peg);
833 :     print "$peg\t$func\n";
834 :     }
835 :     print "\n";
836 :     }
837 :     elsif ($req =~ /^\s*feature_location\s+(\S+)\s*$/)
838 :     {
839 :     $fid = $1;
840 :     if ($loc = $figN->feature_location($fid))
841 :     {
842 :     print "$loc\n";
843 :     }
844 :     else
845 :     {
846 :     print "no location\n";
847 :     }
848 :     }
849 :     elsif ($req =~ /^\s*translation_length\s+(\S+)\s*$/)
850 :     {
851 :     $fid = $1;
852 :     if ($len = $figN->translation_length($fid))
853 :     {
854 :     print "$len\n";
855 :     }
856 :     else
857 :     {
858 :     print "no length for $fid\n";
859 :     }
860 :     }
861 :     elsif ($req =~ /^\s*mapped_prot_ids\s+(\S+)\s*$/)
862 :     {
863 :     foreach $x ($figN->mapped_prot_ids($1))
864 :     {
865 :     ($id,$len) = @$x;
866 :     print &padded($id,20),"\t$len\n";
867 :     }
868 :     print "\n";
869 :     }
870 :     elsif ($req =~ /^\s*boundaries_of\s+(\S+)\s*$/)
871 :     {
872 :     print join("_",$figN->boundaries_of($1)),"\n\n";
873 :     }
874 :     elsif ($req =~ /^\s*family_function\s+(\d+)\s*$/)
875 :     {
876 :     $family = $1;
877 :     $func = $figN->family_function($family);
878 :     print "family $family: $func\n\n";
879 :     }
880 :     elsif ($req =~ /^\s*in_family\s+(\S+)\s*$/)
881 :     {
882 :     $id = $1;
883 :     $n = $figN->in_family($id);
884 :     print "$id is in family $n\n\n";
885 :     }
886 :     elsif ($req =~ /^\s*ids_in_family\s+(\d+)\s*$/)
887 :     {
888 :     $family = $1;
889 :     $func = $figN->family_function($family);
890 :     print "family $family: $func\n\n";
891 :     @ids = $figN->ids_in_family($family);
892 :     while (@ids > 0)
893 :     {
894 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
895 :     print join("\t",@tmp),"\n";
896 :     }
897 :     print "\n";
898 :    
899 :     }
900 :     elsif ($req =~ /^\s*in_sets\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
901 :     {
902 :     $id = $1;
903 :     $relation = $2;
904 :     $set_name = $3;
905 :     print "$id is in set(s) ",join(",",$figN->in_sets($id,$relation,$set_name)),"\n\n";
906 :     }
907 :     elsif ($req =~ /^\s*in_pch_pin_with\s+(\S+)\s*$/)
908 :     {
909 :     $id = $1;
910 :     print "$id is in set(s) ",join(",",$figN->in_pch_pin_with($id)),"\n\n";
911 :     }
912 :     elsif ($req =~ /^\s*exportable_subsystem\s+(\S.*\S+)\s*$/)
913 :     {
914 :     my $ssa = $1;
915 :     my($spreadsheet,$notes) = $figN->exportable_subsystem($ssa);
916 :     print join("",@$spreadsheet),join("",@$notes),"\n";
917 :     }
918 :     elsif ($req =~ /^\s*is_exchangable_subsystem\s+(\S.*\S+)\s*$/)
919 :     {
920 :     my $ssa = $1;
921 :     print $figN->is_exchangable_subsystem($ssa),"\n";
922 :     }
923 :     elsif ($req =~ /^\s*all_exchangable_subsystems\s*$/)
924 :     {
925 :     print join("\n",$figN->all_exchangable_subsystems),"\n";
926 :     }
927 :     elsif ($req =~ /^\s*export_set\s+(\S+)\s+(\S+)\s+(\S+)\s*$/)
928 :     {
929 :     $relation = $1;
930 :     $set_name = $2;
931 :     $file = $3;
932 :     print $figN->export_set($relation,$set_name,$file),"\n\n";
933 :     }
934 :     elsif ($req =~ /^\s*export_chromosomal_clusters\s*$/)
935 :     {
936 :     print $figN->export_set("chromosomal_clusters","cluster_id","$FIG_Config::global/chromosomal_clusters"),"\n\n";
937 :     }
938 :     elsif ($req =~ /^\s*export_pch_pins\s*$/)
939 :     {
940 :     print $figN->export_set("pch_pins","pin","$FIG_Config::global/pch_pins"),"\n\n";
941 :     }
942 :     elsif ($req =~ /^\s*add_chromosomal_clusters\s+(\S+)\s*$/)
943 :     {
944 :     $file = $1;
945 :     print $figN->add_chromosomal_clusters($file),"\n\n";
946 :     }
947 :     elsif ($req =~ /^\s*add_pch_pins\s+(\S+)\s*$/)
948 :     {
949 :     $file = $1;
950 :     print $figN->add_pch_pins($file),"\n\n";
951 :     }
952 :     elsif ($req =~ /^\s*all_sets\s+(\S+)\s+(\S+)\s*$/)
953 :     {
954 :     $relation = $1;
955 :     $set_name = $2;
956 :     print "Set\tSize\n\n";
957 :     foreach $set ($figN->all_sets($relation,$set_name))
958 :     {
959 :     print "$set\t",$figN->sz_set($set,$relation,$set_name),"\n";
960 :     }
961 :     print "\n";
962 :     }
963 :     elsif ($req =~ /^\s*seqs_with_role\s+(\S+)\s+(\S+)\s+(\S.*\S)\s*$/)
964 :     {
965 :     $genome = $1;
966 :     $role = $3;
967 :     $who = $2;
968 :     foreach $peg ($figN->seqs_with_role($role,$who,$genome))
969 :     {
970 :     $func = $figN->function_of($peg,$who);
971 :     print "$peg\t$func\n";
972 :     }
973 :     print "\n";
974 :     }
975 :     elsif ($req =~ /^\s*load_all\s*$/)
976 :     {
977 :     if ($figN->load_all)
978 :     {
979 :     print "imported everything\n";
980 :     }
981 :     }
982 :     elsif ($req =~ /^\s*dsims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+))?\s*$/)
983 :     {
984 :     $file = $1;
985 :     $maxN = $3 ? $3 : 500;
986 :     $maxP = $4 ? $4 : 1,0e-5;
987 :     $select = $5 ? $5 : "raw";
988 :     if (open(TMP,"<$file"))
989 :     {
990 :     $_ = <TMP>;
991 :     while (defined($_) && ($_ =~ /^>(\S+)/))
992 :     {
993 :     $id = $1;
994 :     @seqs = ();
995 :     while (defined($_ = <TMP>) && ($_ !~ /^>/))
996 :     {
997 :     push(@seqs,$_);
998 :     }
999 :     $seq = join("",@seqs);
1000 :     $seq =~ s/\s//gs;
1001 :     if (@sims = $figN->dsims($id,$seq,$maxN,$maxP,$select,0))
1002 :     {
1003 :     print "$id\t",length($seq),"\n\n";
1004 :     foreach $sim (@sims)
1005 :     {
1006 :     $func = $figN->function_of($sim->id2);
1007 :     print join("\t",($sim->id2(),
1008 :     $sim->ln2,
1009 :     $sim->psc,
1010 :     $sim->b1,
1011 :     $sim->e1,
1012 :     $sim->b2,
1013 :     $sim->e2,
1014 :     $sim->iden,
1015 :     $func)),"\n";
1016 :     }
1017 :     print "\n";
1018 :     }
1019 :     }
1020 :     close(TMP);
1021 :     }
1022 :     print "\n";
1023 :     }
1024 :     elsif ($req =~ /^\s*access_sims\s+(\S+)?\s*$/)
1025 :     {
1026 :     $opt = $1 ? $1 : "";
1027 :     foreach $peg ("fig|562.1.peg.14","fig|630.1.peg.589","fig|731.2.peg.1626","fig|75985.1.peg.2319","fig|294.1.peg.4630","fig|305.1.peg.2718","fig|292.1.peg.3262","fig|519.1.peg.4061","fig|633.1.peg.2431","fig|384.1.peg.2479")
1028 :     {
1029 :     @sims = $figN->sims($peg,600,1.0e-3,"raw",0);
1030 :     if ($opt =~ /expand/)
1031 :     {
1032 :     foreach $sim (@sims)
1033 :     {
1034 :     @map = $figN->mapped_prot_ids($sim->id2);
1035 :     foreach $to (@map)
1036 :     {
1037 :     if ($opt =~ /func/)
1038 :     {
1039 :     @funcs = $figN->function_of($to->[0]);
1040 :     }
1041 :     }
1042 :     }
1043 :     }
1044 :     elsif ($opt =~ /func/)
1045 :     {
1046 :     foreach $sim (@sims)
1047 :     {
1048 :     @funcs = $figN->function_of($sim->id2);
1049 :     }
1050 :     }
1051 :     }
1052 :     }
1053 :     elsif ($req =~ /^\s*sims\s+(\S+)(\s+(\S+)\s+(\S+)\s+(\S+)\s+(\d))?\s*$/)
1054 :     {
1055 :     $id = $1;
1056 :     $maxN = $3 ? $3 : 500;
1057 :     $maxP = $4 ? $4 : 1,0e-5;
1058 :     $select = $5 ? $5 : "raw";
1059 :     $tran = $6;
1060 :    
1061 :     $func = $figN->function_of($id);
1062 :     if (@sims = $figN->sims($id,$maxN,$maxP,$select))
1063 :     {
1064 :     print &padded($id,20),"\t",$sims[0]->ln1."\t$func\n\n";
1065 :     foreach $sim (@sims)
1066 :     {
1067 :     $func = $figN->function_of($sim->id2);
1068 :     if ($tran) { $func = $figN->translate_function($func) }
1069 :    
1070 :     $org = $figN->org_of($sim->id2);
1071 :     print join("\t",(&padded($sim->id2,20),
1072 :     $sim->ln2,
1073 :     $sim->psc,
1074 :     $sim->b1,
1075 :     $sim->e1,
1076 :     $sim->b2,
1077 :     $sim->e2,
1078 :     $sim->iden,
1079 :     $org,
1080 :     $func)),"\n";
1081 :     }
1082 :     }
1083 :     print "\n";
1084 :     }
1085 :     elsif ($req =~ /^\s*ids_in_set\s+(\d+)\s+(\S+)\s+(\S+)\s*$/)
1086 :     {
1087 :     $set = $1;
1088 :     $relation = $2;
1089 :     $set_name = $3;
1090 :     print "$set_name $set\n\n";
1091 :     @ids = $figN->ids_in_set($set,$relation,$set_name);
1092 :     while (@ids > 0)
1093 :     {
1094 :     @tmp = splice(@ids,0,$figN->min(3,scalar @ids));
1095 :     print join("\t",@tmp),"\n";
1096 :     }
1097 :     print "\n";
1098 :     }
1099 :    
1100 :     elsif ($req =~ /^\s*get_translations\s+(\S+)(\s+tab)?\s*$/i)
1101 :     {
1102 :     $file = $1;
1103 :     $tab = $2 ? 1 : 0;
1104 :     if (open(TMP,"<$file"))
1105 :     {
1106 :     while (defined($_ = <TMP>))
1107 :     {
1108 :     foreach $id ($_ =~ /\S+/g)
1109 :     {
1110 :     if ($seq = $figN->get_translation($id))
1111 :     {
1112 :     if ($tab)
1113 :     {
1114 :     print "$id\t$seq\n";
1115 :     }
1116 :     else
1117 :     {
1118 :     $figN->display_id_and_seq($id,\$seq);
1119 :     }
1120 :     }
1121 :     }
1122 :     }
1123 :     close(TMP);
1124 :     }
1125 :     else
1126 :     {
1127 :     print STDERR "could not open $file\n";
1128 :     }
1129 :     print "\n";
1130 :     }
1131 :    
1132 :     elsif ($req =~ /^\s*add_annotation\s+(\S+)\s+(\S+)\s*$/)
1133 :     {
1134 :     $fid = $1;
1135 :     $user = $2;
1136 :     print "Type in annotation (end with \".\" at start of line)\n>> ";
1137 :     @ann = ();
1138 :     while (defined($_ = <STDIN>) && ($_ !~ /^\./))
1139 :     {
1140 :     push(@ann,$_);
1141 :     print ">> ";
1142 :     }
1143 :     print $figN->add_annotation($fid,$user,join("",@ann)),"\n\n";
1144 :     }
1145 :    
1146 : efrank 1.1 elsif ($req =~ /^\s*h\s+(\S+)/)
1147 :     {
1148 :     if (-s "Help/$1")
1149 :     {
1150 :     @tmp = `cat Help/$1`;
1151 :     print "\n",join("",@tmp),"\n";
1152 :     }
1153 :     else
1154 :     {
1155 :     print "sorry, no help for $1\n\n";
1156 :     }
1157 :     }
1158 :     else
1159 :     {
1160 :     print "invalid command\n";
1161 :     }
1162 :     print "\n";
1163 :     $req = "";
1164 :    
1165 :     if ($time_cmds)
1166 :     {
1167 :     $t2 = gettimeofday;
1168 :     print $t2-$t1," seconds to execute command\n\n";
1169 :     }
1170 :     }
1171 :     sub padded {
1172 :     my($x,$n) = @_;
1173 :    
1174 :     if (length($x) < $n)
1175 :     {
1176 :     return $x . (" " x ($n - length($x)));
1177 :     }
1178 :     return $x;
1179 :     }
1180 :    
1181 :     sub get_req {
1182 :     my($x);
1183 :    
1184 :     print "?? ";
1185 :     $x = <STDIN>;
1186 :     while (defined($x) && ($x =~ /^h$/i) )
1187 :     {
1188 :     &help;
1189 :     print "?? ";
1190 :     $x = <STDIN>;
1191 :     }
1192 :    
1193 :     if ((! defined($x)) || ($x =~ /^\s*[qQxX]/))
1194 :     {
1195 :     return "";
1196 :     }
1197 :     else
1198 :     {
1199 :     if ($echo)
1200 :     {
1201 :     print ">> $x\n";
1202 :     }
1203 :     return $x;
1204 :     }
1205 :     }
1206 :    
1207 :     sub help {
1208 :     print <<END;
1209 : mkubal 1.2 DB Current DB
1210 :     abbrev genome_name
1211 :     add_annotation FID User [ prompted for annotation; terminate with "." at start of line ]
1212 :     add_chromosomal_clusters File
1213 :     *add_genome GenomeDir
1214 :     add_pch_pins File
1215 :     all_compounds
1216 :     all_features GenomeID Type
1217 :     all_maps
1218 : efrank 1.1 all_protein_families
1219 : mkubal 1.2 all_reactions
1220 :     all_roles
1221 :     all_sets Relation SetName
1222 :     assign_function PEG User [conf=X] Function
1223 :     assign_functionF User File
1224 :     assignments_made who date G1 G2 ... [ none => all ]
1225 :     auto_assign PEG [Seq]
1226 :     auto_assignF User FileOfPEGs
1227 :     auto_assignG User GenomeID1 GenomeID2 ...
1228 :     between n1 n2 n3
1229 :     blast PEG [against nr]
1230 :     blastit PEG seq db maxP
1231 :     boundaries_of Loc
1232 :     build_tree_of_complete min_for_label
1233 :     by_alias alias
1234 :     by_fig_id FID1 FID2
1235 :     cas CID
1236 :     cas_to_cid cas
1237 :     catalyzed_by RID
1238 : efrank 1.1 catalyzes role
1239 : mkubal 1.2 cgi_url
1240 :     clean_tmp
1241 :     close_genes FID distance
1242 :     comp2react CID
1243 :     contig_ln GenomeID Contig
1244 :     coupling_and_evidence FID Bound SimCutoff CouplingCutoff
1245 :     crude_estimate_of_distance GenomeID1 GenomeID2
1246 :     delete_genomes G1 G2 G3 ...Gn
1247 :     displayable_reaction RID
1248 :     dna_seq GenomeID Loc
1249 :     dsims FastaFile [MaxN MaxPsc Select] *** select defaults to raw
1250 :     ec_to_maps EC
1251 :     ec_name EC
1252 :     expand_ec EC
1253 :     epoch_to_readable [gives readable version of current time]
1254 :     export_chromosomal_clusters
1255 :     export_pch_pins
1256 :     export_set Relation SetName File
1257 :     exportable_subsystem Subsystem
1258 :     extract_seq ContigsFile loc
1259 :     all_exchangable_subsystems
1260 :     family_function Family
1261 :     fast_coupling FID Bound CouplingCutoff
1262 :     feature_aliases FID
1263 :     feature_annotations FID
1264 :     feature_location FID
1265 :     file2N File
1266 :     ftype FID
1267 :     function_of ID [all] [trans]
1268 :     genes_in_region GenomeID Contig Beg End
1269 :     genome_of PEG
1270 :     genomes [complete|Pat]
1271 :     genome_counts [complete]
1272 :     genome_version GenomeID
1273 :     genus_species GenomeID
1274 :     get_translation ID
1275 :     get_translations File [tab]
1276 : efrank 1.1 h [command] *** h h for help on how to use help ***
1277 : mkubal 1.2 hypo Function
1278 :     ids_in_family Family
1279 :     ids_in_set WhichSet Relation SetName
1280 :     in_cluster_with PEG
1281 :     in_family FID
1282 :     in_pch_pin_with FID
1283 :     in_sets Which Relation SetName
1284 :     is_archaeal GenomeID
1285 :     is_bacterial GenomeID
1286 :     is_eukaryotic GenomeID
1287 :     is_prokaryotic GenomeID
1288 :     is_exchangable_subsystem Subsystem
1289 :     is_real_feature FID
1290 :     largest_clusters FileOfRoles user
1291 :     load_all
1292 : efrank 1.1 map_to_ecs map
1293 : mkubal 1.2 map_name map
1294 :     mapped_prot_ids ID
1295 :     maps_to_id ID
1296 :     max n1 n2 n3 ...
1297 :     merged_related_annotations PEG1 PEG2 ... PEGn
1298 :     min n1 n2 n3 ...
1299 :     names_of_compound
1300 :     neighborhood_of_role role
1301 :     org_of prot_id
1302 :     pegs_of GenomeID
1303 :     possibly_truncated FID
1304 :     reaction2comp RID
1305 :     related_by_func_sim PEG user
1306 :     reversible RID
1307 :     rnas_of GenomeID
1308 :     roles_of_function function
1309 :     search_index pattern
1310 :     seqs_with_role role who
1311 :     seqs_with_roles_in_genomes genomes roles made_by
1312 :     sims PEG maxN maxP select
1313 :     sort_fids_by_taxonomy FID1 FID2 FID3 ...
1314 :     sort_genomes_by_taxonomy GenomeID1 GenomeID2 GenomeID3 ...
1315 :     sz_family family
1316 :     taxonomic_groups_of_complete min_for_labels
1317 :     taxonomy_of GenomeID
1318 :     translatable prot_id
1319 :     translate_function PEG user
1320 :     translated_function_of PEG user
1321 :     translation_length ID
1322 :     unique_functions PEGs user [make the pegs comma separated]
1323 :     verify_dir dir
1324 : efrank 1.1
1325 :     END
1326 :     }

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3