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

Diff of /FigKernelScripts/fig_net.pl

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1, Mon Dec 1 20:46:40 2003 UTC revision 1.2, Mon Jun 21 22:08:14 2004 UTC
# Line 5  Line 5 
5    
6  use FIGnet;  use FIGnet;
7  use FIG;  use FIG;
8    use Blast;
9    
10  my($user);  my($user);
11    
12  # usage: fig $url [-echo] [-time] [command]  my $usage = "usage: fig_net $url [-echo] [-time] [command]";
13    
14  defined($url = shift @ARGV)  defined($url = shift @ARGV)
15      || die "usage: fig $url [-echo] [-time] [command]";      || die $usage;
16    
17  $figN = new FIGnet($url);  $figN = new FIGnet($url);
18  $fig  = new FIG;  $fig  = new FIG;
# Line 25  Line 26 
26      if ($arg =~ /^-echo/i) { $echo      = 1 }      if ($arg =~ /^-echo/i) { $echo      = 1 }
27  }  }
28    
29  my($t1,$t2);  my($t1,$t2,$i);
30  if (@ARGV > 0)  { $req = join( " ", @ARGV ); }  if (@ARGV > 0)  { $req = join( " ", @ARGV ); }
31  while ( (defined($req) && $req) || ($req = &get_req) )  while ( (defined($req) && $req) || ($req = &get_req) )
32  {  {
# Line 34  Line 35 
35          $t1 = gettimeofday;          $t1 = gettimeofday;
36      }      }
37    
38      if ($req =~ /^\s*genomes(\s+(\S.*\S))?\s*$/)      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      {      {
59          $pat = $2;          $pat = $2;
60          foreach $genome ($figN->genomes)          foreach $genome ($figN->genomes)
61          {          {
62              my $genus_species = $fig->genus_species($genome);              my $genus_species = $figN->genus_species($genome);
63              if ((! $pat) || ($genus_species =~ /$pat/))              if ((! $pat) || ($genus_species =~ /$pat/))
64              {              {
65                  print join("\t",(&padded($genome,15),$genus_species)),"\n";                  print join("\t",(&padded($genome,15),$genus_species)),"\n";
# Line 159  Line 179 
179          $who = $3;          $who = $3;
180          $genomes = [map { chop; $_ } `cat $genomesF`];          $genomes = [map { chop; $_ } `cat $genomesF`];
181          $roles   = [map { chop; $_ } `cat $rolesF`];          $roles   = [map { chop; $_ } `cat $rolesF`];
         print &Dumper($figN->seqs_with_roles_in_genomes($genomes,$roles,$who));  
182          print "\n";          print "\n";
183      }      }
184        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      elsif ($req =~ /^\s*h\s+(\S+)/)      elsif ($req =~ /^\s*h\s+(\S+)/)
1147      {      {
1148          if (-s "Help/$1")          if (-s "Help/$1")
# Line 225  Line 1206 
1206    
1207  sub help {  sub help {
1208      print <<END;      print <<END;
1209      Those not implemented yet are marked with an *:      DB                              Current DB
1210        abbrev                          genome_name
1211  *   add_annotation                  FID User [ prompted for annotation; terminate with "." at start of line ]      add_annotation                  FID User [ prompted for annotation; terminate with "." at start of line ]
1212  *   add_chromosomal_clusters        File      add_chromosomal_clusters        File
1213  *   add_pch_pins                    File     *add_genome                      GenomeDir
1214        add_pch_pins                    File
1215        all_compounds
1216        all_features                    GenomeID Type
1217      all_maps      all_maps
1218      all_protein_families      all_protein_families
 *   assign_function                 PEG User [conf=X] Function  
 *   assign_functionF                User File  
 *   auto_assign                     PEG [Seq]  
 *   blast                           PEG  [against nr]  
 *   cas                             cid  
 *   cas_to_cid                      cas  
     catalyzed_by                    rid  
     catalyzes                       role  
     comp2react                      cid  
 *   contig_ln                       Genome Contig  
 *   coupling_and_evidence           Fid Bound SimCutoff CouplingCutoff  
 *   dna_seq                         Genome Loc  
 *   dsims                           FastaFile [MaxN MaxPsc Select]   *** select defaults to raw  
 *   ec_to_maps                      EC  
 *   family_function                 Family  
 *   feature_annotations             FID  
 *   feature_location                Fid  
     all_compounds  
 *   all_features                    Genome Type  
1219      all_reactions      all_reactions
1220  *   function_of                     ID [all]      all_roles
1221  *   genes_in_region                 Org Contig Beg End      all_sets                        Relation SetName
1222  *   genome_of                       Prot      assign_function                 PEG User [conf=X] Function
1223      genomes                         [Pat]      assign_functionF                User File
1224  *   genome_version                  Genome      assignments_made                who date G1 G2 ...  [ none => all ]
1225  *   genus_species                   Org      auto_assign                     PEG [Seq]
1226  *   get_translation                 ID      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        catalyzes                       role
1239        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      h                               [command]  *** h h for help on how to use help ***      h                               [command]  *** h h for help on how to use help ***
1277  *   ids_in_family                   Family      hypo                            Function
1278  *   in_cluster_with                 Peg      ids_in_family                   Family
1279  *   in_family                       Fid      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      map_to_ecs                      map      map_to_ecs                      map
1293  *   map_name                        map      map_name                        map
1294  *   mapped_prot_ids                 ID      mapped_prot_ids                 ID
1295      names_of_compound               cid      maps_to_id                      ID
1296      names_of_compounds      max                             n1 n2 n3 ...
1297  *   neighborhood_of_role            Role      merged_related_annotations      PEG1 PEG2 ... PEGn
1298  *   org_of                          ID      min                             n1 n2 n3 ...
1299      reaction2comp                   rid      names_of_compound
1300  *   restricted      neighborhood_of_role            role
1301      reversible                      rid      org_of                          prot_id
1302      seqs_with_roles_in_genomes      GenomesFile RolesFile Who      pegs_of                         GenomeID
1303  *   sims                            ID [MaxN MaxPsc Select]   *** select defaults to raw      possibly_truncated              FID
1304  *   sz_family                       Family      reaction2comp                   RID
1305  *   taxonomy_of                     Org      related_by_func_sim             PEG user
1306  *   translation_length              ID      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    
1325  END  END
1326  }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3