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

Annotation of /FigKernelScripts/fig_rpc.pl

Parent Directory Parent Directory | Revision Log Revision Log


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

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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3