[Bio] / FigKernelPackages / FIGrpc.pm Repository:
ViewVC logotype

Annotation of /FigKernelPackages/FIGrpc.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : mkubal 1.1 package FIGrpc;
2 :    
3 :     use Carp;
4 :     use Data::Dumper;
5 :    
6 :     use strict;
7 :     use FIG;
8 :     use Frontier::Client;
9 :    
10 :     sub new {
11 :     my($class,$url) = @_;
12 :    
13 :     if (! $url)
14 :     {
15 :     my $fig = new FIG;
16 :     return $fig;
17 :     }
18 :     else
19 :     {
20 :     my($proxy);
21 :    
22 :     $proxy = Frontier::Client->new(url => $url);
23 :    
24 :     my $self = {
25 :     _url => $url,
26 :     _proxy => $proxy,
27 :     };
28 :    
29 :     return bless $self, $class;
30 :     }
31 :     }
32 :    
33 :     sub DESTROY {
34 :     my($self) = @_;
35 :     my($fig);
36 :    
37 :     if ($fig = $self->{_fig})
38 :     {
39 :     $fig->DESTROY;
40 :     }
41 :     }
42 :    
43 :     =pod
44 :    
45 :     =head1 set_remote
46 :    
47 :     usage: $fig->set_remote($url)
48 :    
49 :     Sets the remote version of FIG to the one given by $url.
50 :    
51 :     =cut
52 :    
53 :     sub set_remote_FIG {
54 :     my($self,$url) = @_;
55 :    
56 :     $self->{_url} = $url;
57 :     }
58 :    
59 :    
60 :     =pod
61 :    
62 :     =head1 current_FIG
63 :    
64 :     usage: $url = $fig->current_FIG
65 :    
66 :     Returns the URL of the current FIG ("" for a local copy).
67 :    
68 :     =cut
69 :    
70 :     sub current_FIG {
71 :     my($self) = @_;
72 :    
73 :     return $self->{_url} ? $self->{_url} : "";
74 :     }
75 :    
76 :    
77 :     =pod
78 :    
79 :     =head1 genomes
80 :    
81 :     usage: @genome_ids = $fig->genomes;
82 :    
83 :     Genomes are assigned ids of the form X.Y where X is the taxonomic id maintained by
84 :     NCBI for the species (not the specific strain), and Y is a sequence digit assigned to
85 :     this particular genome (as one of a set with the same genus/species). Genomes also
86 :     have versions, but that is a separate issue.
87 :    
88 :     =cut
89 :    
90 :     sub get_proxy
91 :     {
92 :     my($self) = @_;
93 :    
94 :     return $self->{_proxy};
95 :     }
96 :    
97 :     sub genomes {
98 :     my($self) = @_;
99 :     my $gen = $self->get_proxy()->call("genomes");
100 :     return $gen;
101 :     }
102 :    
103 :     sub genome_counts {
104 :     my($self,$complete) = @_;
105 :     my $counts = $self->get_proxy()->call("genome_counts",$complete);
106 :     return $counts;
107 :     }
108 :    
109 :     sub genome_version {
110 :     my($self,$genome) = @_;
111 :     my $version = $self->get_proxy()->call("genome_version",$genome);
112 :     return $version;
113 :    
114 :     }
115 :    
116 :     sub genus_species {
117 :     my($self,$genome) = @_;
118 :     my $gs = $self->get_proxy()->call("genus_species",$genome);
119 :     return $gs;
120 :     }
121 :    
122 :     ############################# KEGG Stuff ####################################
123 :    
124 :    
125 :     =pod
126 :    
127 :     =head1 all_maps
128 :    
129 :     usage: @maps = $fig->all_maps
130 :    
131 :     Returns a list containing all of the KEGG maps that the system knows about (the
132 :     maps need to be periodically updated).
133 :    
134 :     =cut
135 :    
136 :     sub all_maps {
137 :     my($self) = @_;
138 :     return my @results = $self->get_proxy()->call("all_maps");
139 :     }
140 :    
141 :    
142 :     =pod
143 :    
144 :     =head1 map_to_ecs
145 :    
146 :     usage: @ecs = $fig->map_to_ecs($map)
147 :    
148 :     Returns the set of functional roles (usually ECs) that are contained in the functionality
149 :     depicted by $map.
150 :    
151 :     =cut
152 :    
153 :     sub map_to_ecs {
154 :     my($self,$map) = @_;
155 :     return my @results = $self->get_proxy()->call("map_to_ecs",$map);
156 :     }
157 :    
158 :    
159 :     =pod
160 :    
161 :     =head1 all_compounds
162 :    
163 :     usage: @compounds = $fig->all_compounds
164 :    
165 :     Returns a list containing all of the KEGG compounds.
166 :    
167 :     =cut
168 :    
169 :     sub all_compounds {
170 :     my($self) = @_;
171 :     return my @results = $self->get_proxy()->call("all_compounds");
172 :     }
173 :    
174 :     sub names_of_compound {
175 :     my($self,$cid) = @_;
176 :     return my @results = $self->get_proxy()->call("names_of_compound");
177 :     }
178 :    
179 :     =pod
180 :    
181 :     =head1 comp2react
182 :    
183 :    
184 :     usage: @rids = $fig->comp2react($cid)
185 :    
186 :     Returns a list containing all of the reaction IDs for reactions that take $cid
187 :     as either a substrate or a product.
188 :    
189 :     =cut
190 :    
191 :     sub comp2react {
192 :     my($self,$cid) = @_;
193 :     return my $result = $self->get_proxy()->call("comp2react",$cid);
194 :     }
195 :    
196 :    
197 :     =pod
198 :    
199 :     =head1 all_reactions
200 :    
201 :     usage: @rids = $fig->all_reactions
202 :    
203 :     Returns a list containing all of the KEGG reaction IDs.
204 :    
205 :     =cut
206 :    
207 :     sub all_reactions {
208 :     my($self) = @_;
209 :     return my @results = $self->get_proxy()->call("all_reactions");
210 :     }
211 :    
212 :    
213 :     =pod
214 :    
215 :     =head1 reversible
216 :    
217 :     usage: $rev = $fig->reversible($rid)
218 :    
219 :     Returns true iff the reactions had a "main direction" designated as "<=>";
220 :    
221 :     =cut
222 :    
223 :     sub reversible {
224 :     my($self,$rid) = @_;
225 :     return my $result = $self->get_proxy()->call("reversible",$rid);
226 :     }
227 :    
228 :    
229 :     =pod
230 :    
231 :     =head1 catalyzed_by
232 :    
233 :     usage: @ecs = $fig->catalyzed_by($rid)
234 :    
235 :     Returns the ECs that are reputed to catalyze the reaction. Note that we are currently
236 :     just returning the ECs that KEGG gives. We need to handle the incompletely specified forms
237 :     (e.g., 1.1.1.-), but we do not do it yet.
238 :    
239 :     =cut
240 :    
241 :     sub catalyzed_by {
242 :     my($self,$rid) = @_;
243 :     return my @results = $self->get_proxy()->call("catalyzed_by",$rid);
244 :     }
245 :    
246 :    
247 :     =pod
248 :    
249 :     =head1 catalyzes
250 :    
251 :     usage: @ecs = $fig->catalyzes($role)
252 :    
253 :     Returns the rids of the reactions catalyzed by the "role" (normally an EC).
254 :    
255 :     =cut
256 :    
257 :     sub catalyzes {
258 :     my($self,$role) = @_;
259 :     return my @results = $self->get_proxy()->call("catalyzes",$role);
260 :     }
261 :    
262 :     sub reaction2comp {
263 :     my($self,$rid,$which) = @_;
264 :     return my @results = $self->get_proxy()->call("reaction2comp",$rid,$which);
265 :     }
266 :    
267 :     sub seqs_with_roles_in_genomes {
268 :     my($self,$genomes,$roles,$who) = @_;
269 :     return my @results = $self->get_proxy()->call("seqs_with_roles_in_genome",$genomes,$roles,$who);
270 :     }
271 :    
272 :     sub abbrev {
273 :     my($self,$genome_name) = @_;
274 :     return my $result = $self->get_proxy()->call("abbrev",$genome_name);
275 :     }
276 :    
277 :     sub fast_coupling {
278 :     my($self,$peg,$bound,$coupling_cutoff) = @_;
279 :     return my @results = $self->get_proxy()->call("fast_coupling",$peg,$bound,$coupling_cutoff);
280 :     }
281 :    
282 :    
283 :     sub family_function {
284 :     my($self,$family) = @_;
285 :     return my $result = $self->get_proxy()->call("family_function",$family);
286 :     }
287 :    
288 :     sub feature_annotations {
289 :     my($self,$feature_id) = @_;
290 :     return my @results = $self->get_proxy()->call("feature_annotations",$feature_id);
291 :     }
292 :    
293 :     sub dna_seq {
294 :     my($self,$genome,@locations) = @_;
295 :     return my $result = $self->get_proxy()->call("dna_seq",$genome,@locations);
296 :     }
297 :    
298 :     sub all_protein_families {
299 :     my($self) = @_;
300 :     return my @results = $self->get_proxy()->call("all_protein_families");
301 :     }
302 :    
303 :     sub all_sets {
304 :     my($self,$relation,$set_name) = @_;
305 :     return my @results = $self->get_proxy()->call("all_sets",$relation,$set_name);
306 :     }
307 :    
308 :     sub db_handle {
309 :     my($self) = @_;
310 :     return my $result = $self->get_proxy()->call("db_handle");
311 :     }
312 :    
313 :     sub all_features {
314 :     my($self,$genome,$type) = @_;
315 :     return my @results = $self->get_proxy()->call("all_features",$genome,$type);
316 :     }
317 :    
318 :     sub sz_family {
319 :     my($self,$family) = @_;
320 :     return my $result = $self->get_proxy()->call("sz_family",$family);
321 :     }
322 :    
323 :     sub sz_set {
324 :     my($self,$which,$relation,$set_name) = @_;
325 :     return my $result = $self->get_proxy()->call("sz_set",$which,$relation,$set_name);
326 :     }
327 :    
328 :     sub cgi_url {
329 :     my($self) = @_;
330 :     return my $result = $self->get_proxy()->call("cgi_url");
331 :     }
332 :    
333 :     sub function_of {
334 :     my($self,$id,$user) = @_;
335 :     return my $result = $self->get_proxy()->call("function_of",$id,$user);
336 :     }
337 :    
338 :     sub get_translation {
339 :     my($self,$id) = @_;
340 :     return my $result = $self->get_proxy()->call("get_translation",$id);
341 :     }
342 :    
343 :     sub org_of {
344 :     my($self,$prot_id) = @_;
345 :     return my $result = $self->get_proxy()->call("org_of",$prot_id);
346 :     }
347 :    
348 :     sub by_alias {
349 :     my($self,$alias) = @_;
350 :     return my $result = $self->get_proxy()->call("by_alias",$alias);
351 :     }
352 :    
353 :     sub by_fig_id {
354 :     my($self,$a,$b) = @_;
355 :     return my $result = $self->get_proxy()->call("by_fig_id",$a,$b);
356 :     }
357 :    
358 :     sub cas {
359 :     my($self,$cid) = @_;
360 :     return my $result = $self->get_proxy()->call("cas",$cid);
361 :     }
362 :    
363 :     sub cas_to_cid {
364 :     my($self,$cas) = @_;
365 :     return my $result = $self->get_proxy()->call("cas_to_cid",$cas);
366 :     }
367 :    
368 :     sub close_genes {
369 :     my($self,$fid,$dist) = @_;
370 :     return my @results = $self->get_proxy()->call("close_genes",$fid,$dist);
371 :     }
372 :    
373 :     sub contig_ln {
374 :     my($self,$genome,$contig) = @_;
375 :     return my $result = $self->get_proxy()->call("contig_ln",$genome,$contig);
376 :     }
377 :    
378 :     sub coupling_and_evidence {
379 :     my($self,$fid,$bound,$sim_cutoff,$coup_cutoff) = @_;
380 :     return my @results = $self->get_proxy()->call("coupling_and_evidence",$fid,$bound,$sim_cutoff,$coup_cutoff);
381 :     }
382 :    
383 :     sub crude_estimate_of_distance {
384 :     my($self,$genome1,$genome2) = @_;
385 :     return my $result = $self->get_proxy()->call("crude_estimate_of_distance",$genome1,$genome2);
386 :     }
387 :    
388 :     sub displayable_reaction {
389 :     my($self,$rid) = @_;
390 :     return my $result = $self->get_proxy()->call("displayable_reaction",$rid);
391 :     }
392 :    
393 :     sub add_annotation {
394 :     my($self,$feature_id,$user,$annotation) = @_;
395 :     return my $result = $self->get_proxy()->call("add_annotation",$feature_id,$user,$annotation);
396 :     }
397 :    
398 :     sub add_chromosomal_clusters {
399 :     my($self,$file) = @_;
400 :     return my $result = $self->get_proxy()->call("add_chromosomal_clusters",$file);
401 :     }
402 :    
403 :     sub add_genome {
404 :     my($self,$genomeF) = @_;
405 :     return my $result = $self->get_proxy()->call("add_genome",$genomeF);
406 :     }
407 :    
408 :     sub add_pch_pins {
409 :     my($self,$file) = @_;
410 :     return my $result = $self->get_proxy()->call("add_pch_pins",$file);
411 :     }
412 :    
413 :     sub min {
414 :     my($self,@x) = @_;
415 :     return my $result = $self->get_proxy()->call("min",@x);
416 :     }
417 :    
418 :     sub all_roles {
419 :     my($self) = @_;
420 :     return my @results = $self->get_proxy()->call("all_roles");
421 :     }
422 :    
423 :     sub assign_function {
424 :     my($self,$peg,$user,$function,$confidence) = @_;
425 :     return my $result = $self->get_proxy()->call("assign_function",$peg,$user,$function,$confidence);
426 :     }
427 :    
428 :     sub assignments_made {
429 :     my($self,$genomes,$who,$date) = @_;
430 :     return my @results = $self->get_proxy()->call("assignments_made",$genomes,$who,$date);
431 :     }
432 :    
433 :     sub auto_assign {
434 :     my($self,$peg,$seq) = @_;
435 :     return my $result = $self->get_proxy()->call("auto_assign",$peg,$seq);
436 :    
437 :     }
438 :    
439 :     sub between {
440 :     my($self,$x,$y,$z) = @_;
441 :     return my $result = $self->get_proxy()->call("between",$x,$y,$z);
442 :     }
443 :    
444 :     sub delete_genomes {
445 :     my($self,$genomes) = @_;
446 :     return my $result = $self->get_proxy()->call("delete_genomes",$genomes);
447 :     }
448 :    
449 :     sub dsims {
450 :     my($self,$id,$seq,$maxN,$maxP,$select) = @_;
451 :     return my @results = $self->get_proxy()->call("dsims",$id,$seq,$maxN,$maxP,$select);
452 :     }
453 :    
454 :     sub ec_to_maps {
455 :     my($self,$ec) = @_;
456 :     return my @results = $self->get_proxy()->call("ec_to_maps",$ec);
457 :     }
458 :    
459 :     sub ec_name {
460 :     my($self,$ec) = @_;
461 :     return my $result = $self->get_proxy()->call("ec_name",$ec);
462 :     }
463 :    
464 :     sub expand_ec {
465 :     my($self,$ec) = @_;
466 :     return my $result = $self->get_proxy()->call("expand_ec",$ec);
467 :     }
468 :    
469 :     sub epoch_to_readable {
470 :     my($epoch) = @_;
471 :     my($sec,$min,$hr,$dd,$mm,$yr) = localtime($epoch);
472 :     $mm++;
473 :     $yr += 1900;
474 :     return "$mm-$dd-$yr:$hr:$min:$sec";
475 :     }
476 :    
477 :     sub export_chromosomal_clusters {
478 :     my($self) = @_;
479 :     return my $result = $self->get_proxy()->call("expand_ec");
480 :     }
481 :    
482 :     sub export_pch_pins {
483 :     my($self) = @_;
484 :     return my $result = $self->get_proxy()->call("export_pch_pins");
485 :     }
486 :    
487 :     sub extract_seq {
488 :     my($self,$contigs,$loc) = @_;
489 :     return my $result = $self->get_proxy()->call("extract_seq",$contigs,$loc);
490 :     }
491 :    
492 :     sub all_exchangable_subsystems {
493 :     my($self) = @_;
494 :     return my @results = $self->get_proxy()->call("all_exchangable_subsystems");
495 :     }
496 :    
497 :     sub feature_aliases {
498 :     my($self,$feature_id) = @_;
499 :     return my @results = $self->get_proxy()->call("feature_aliases",$feature_id);
500 :     }
501 :    
502 :     sub feature_location {
503 :     my($self,$feature_id) = @_;
504 :     return my $result = $self->get_proxy()->call("feature_location",$feature_id);
505 :     }
506 :    
507 :     sub file2N {
508 :     my($self,$file) = @_;
509 :     return my $result = $self->get_proxy()->call("file2N",$file);
510 :     }
511 :    
512 :     sub ftype {
513 :     my($self,$feature_id) = @_;
514 :     return my $result = $self->get_proxy()->call("ftype",$feature_id);
515 :     }
516 :    
517 :     sub genes_in_region {
518 :     my($self,$genome,$contig,$beg,$end) = @_;
519 :     return my @results = $self->get_proxy()->call("genes_in_region",$genome,$contig,$beg,$end);
520 :     }
521 :    
522 :     sub blastit {
523 :     my($self,$id,$seq,$db,$maxP) = @_;
524 :     return my @results = $self->get_proxy()->call("blastit",$id,$seq,$db,$maxP);
525 :     }
526 :    
527 :     sub boundaries_of {
528 :     my($self,$location) = (@_ == 1) ? $_[0] : $_[1];
529 :     return my $result = $self->get_proxy()->call("boundaries_of",$location);
530 :     }
531 :    
532 :     sub build_tree_of_complete {
533 :     my($self,$min_for_label) = @_;
534 :     return my @results = $self->get_proxy()->call("build_tree_of_complete",$min_for_label);
535 :     }
536 :    
537 :     sub clean_tmp {
538 :     my($self,$file);
539 :     return my $result = $self->get_proxy()->call("clean_tmp",$file);
540 :     }
541 :    
542 :     sub hypo {
543 :     my $x = (@_ == 1) ? $_[0] : $_[1];
544 :    
545 :     if (! $x) { return 1 }
546 :     if ($x =~ /hypoth/i) { return 1 }
547 :     if ($x =~ /conserved protein/i) { return 1 }
548 :     if ($x =~ /gene product/i) { return 1 }
549 :     if ($x =~ /interpro/i) { return 1 }
550 :     if ($x =~ /B[sl][lr]\d/i) { return 1 }
551 :     if ($x =~ /^U\d/) { return 1 }
552 :     if ($x =~ /^orf/i) { return 1 }
553 :     if ($x =~ /uncharacterized/i) { return 1 }
554 :     if ($x =~ /psedogene/i) { return 1 }
555 :     if ($x =~ /^predicted/i) { return 1 }
556 :     if ($x =~ /AGR_/) { return 1 }
557 :     if ($x =~ /similar to/i) { return 1 }
558 :     if ($x =~ /similarity/i) { return 1 }
559 :     if ($x =~ /glimmer/i) { return 1 }
560 :     if ($x =~ /unknown/i) { return 1 }
561 :     return 0;
562 :     }
563 :    
564 :     sub ids_in_family {
565 :     my($self,$family) = @_;
566 :     return my @results = $self->get_proxy()->call("ids_in_family",$family);
567 :     }
568 :    
569 :     sub ids_in_set {
570 :     my($self,$which,$relation,$set_name) = @_;
571 :     return my @results = $self->get_proxy()->call("ids_in_set",$which,$relation,$set_name);
572 :     }
573 :    
574 :     sub in_cluster_with {
575 :     my($self,$peg) = @_;
576 :     return my @results = $self->get_proxy()->call("in_cluster_with",$peg);
577 :     }
578 :    
579 :     sub in_family {
580 :     my($self,$id) = @_;
581 :     return my $result = $self->get_proxy()->call("in_family",$id);
582 :     }
583 :    
584 :     sub in_pch_pin_with {
585 :     my($self,$peg) = @_;
586 :     return my @results = $self->get_proxy()->call("in_pch_with",$peg);
587 :     }
588 :    
589 :     sub in_sets {
590 :     my($self,$id,$relation,$set_name) = @_;
591 :     return my @results = $self->get_proxy()->call("in_sets",$id,$relation,$set_name);
592 :     }
593 :    
594 :     sub is_archaeal {
595 :     my($self,$genome) = @_;
596 :     return my $result = $self->get_proxy()->call("is_archaeal",$genome);
597 :     }
598 :    
599 :     sub is_bacterial {
600 :     my($self,$genome) = @_;
601 :     return my $result = $self->get_proxy()->call("is_bacterial",$genome);
602 :     }
603 :    
604 :     sub is_eukaryotic {
605 :     my($self,$genome) = @_;
606 :     return my $result = $self->get_proxy()->call("is_eukaryotic",$genome);
607 :     }
608 :    
609 :     sub is_prokaryotic {
610 :     my($self,$genome) = @_;
611 :     return my $result = $self->get_proxy()->call("is_prokayotic",$genome);
612 :     }
613 :    
614 :     sub is_exchangable_subsystem {
615 :     my($self,$subsystem) = @_;
616 :     return my $result = $self->get_proxy()->call("is_exchangable_subsystem",$subsystem);
617 :     }
618 :    
619 :     sub is_real_feature {
620 :     my($self,$fid) = @_;
621 :     return my $result = $self->get_proxy()->call("is_real_feature",$fid);
622 :     }
623 :    
624 :     sub largest_clusters {
625 :     my($self,$roles,$user,$sort_by_unique_functions) = @_;
626 :     return my @results = $self->get_proxy()->call("largest_clusters",$roles,$user,$sort_by_unique_functions);
627 :     }
628 :    
629 :     sub load_all {
630 :     my($self) = @_;
631 :     $self->get_proxy()->call("load_all");
632 :     }
633 :    
634 :     sub map_name {
635 :     my($self,$map) = @_;
636 :     return my $result = $self->get_proxy()->call("map_name",$map);
637 :     }
638 :    
639 :     sub mapped_prot_ids {
640 :     my($self,$id) = @_;
641 :     return my @results = $self->get_proxy()->call("mapped_prot_ids",$id);
642 :     }
643 :    
644 :     sub maps_to_id {
645 :     my($self,$id) = @_;
646 :     return my @results = $self->get_proxy()->call("maps_to_id",$id);
647 :     }
648 :    
649 :     sub max {
650 :     my($self,@x) = @_;
651 :     return my $result = $self->get_proxy()->call("max",@x);
652 :     }
653 :    
654 :     sub merged_related_annotations {
655 :     my($self,$fids) = @_;
656 :     return my @results = $self->get_proxy()->call("merged_related_annotations",$fids);
657 :     }
658 :    
659 :     sub neighborhood_of_role {
660 :     my($self,$role) = @_;
661 :     return my @results = $self->get_proxy()->call("neighborhood_of_role",$role);
662 :     }
663 :    
664 :     sub pegs_of {
665 :     my($self,$genome) = @_;
666 :     return my @results = $self->get_proxy()->call("pegs_of",$genome);
667 :     }
668 :    
669 :     sub possibly_truncated {
670 :     my($self,$feature_id) = @_;
671 :     return my $result = $self->get_proxy()->call("possibly_truncated",$feature_id);
672 :     }
673 :    
674 :     sub related_by_func_sim {
675 :     my($self,$peg,$user) = @_;
676 :     return my @results = $self->get_proxy()->call("related_by_func_sim",$peg,$user);
677 :     }
678 :    
679 :     sub rnas_of {
680 :     my($self,$genome) = @_;
681 :     return my @results = $self->get_proxy()->call("rnas_of",$genome);
682 :     }
683 :    
684 :     sub roles_of_function {
685 :     my($self,$func) = @_;
686 :     return my @results = $self->get_proxy()->call("roles_of_function",$func);
687 :     }
688 :    
689 :     sub search_index {
690 :     my($self,$pattern) = @_;
691 :     return my @results = $self->get_proxy()->call("search_index",$pattern);
692 :     }
693 :    
694 :     sub seqs_with_role {
695 :     my($self,$role,$who,$genome) = @_;
696 :     return my @results = $self->get_proxy()->call("seqs_with_role",$role,$who,$genome);
697 :     }
698 :    
699 :     sub sims {
700 :     my ($self,$id,$maxN,$maxP,$select,$max_expand) = @_;
701 :     return my @results = $self->get_proxy()->call("sims",$id,$maxN,$maxP,$select,$max_expand);
702 :     }
703 :    
704 :     sub sort_genomes_by_taxonomy {
705 :     my($self,@genomes) = @_;
706 :     return my @results = $self->get_proxy()->call("sort_genomes_by_taxonomy",@genomes);
707 :     }
708 :    
709 :     sub sort_fids_by_taxonomy {
710 :     my($self,@fids) = @_;
711 :     return my @results = $self->get_proxy()->call("sort_fids_by_taxonomy",@fids);
712 :     }
713 :    
714 :     sub taxonomic_groups_of_complete {
715 :     my($self,$min_for_labels) = @_;
716 :     return my @results = $self->get_proxy()->call("taxonomic_groups_of_complete",$min_for_labels);
717 :     }
718 :    
719 :     sub taxonomy_of {
720 :     my($self,$genome) = @_;
721 :     return my $result = $self->get_proxy()->call("taxonomy_of",$genome);
722 :     }
723 :    
724 :     sub translatable {
725 :     my($self,$prot) = @_;
726 :     return my $result = $self->get_proxy()->call("translatable",$prot);
727 :     }
728 :    
729 :     sub translate_function {
730 :     my($self,$function) = @_;
731 :     return my $result = $self->get_proxy()->call("translate_function",$function);
732 :     }
733 :    
734 :     sub translated_function_of {
735 :     my($self,$id,$user) = @_;
736 :     return my $result = $self->get_proxy()->call("translated_function_of",$id,$user);
737 :     }
738 :    
739 :     sub translation_length {
740 :     my($self,$fid) = @_;
741 :     return my $result = $self->get_proxy()->call("translation_length",$fid);
742 :     }
743 :    
744 :     sub unique_functions {
745 :     my($self,$pegs,$user) = @_;
746 :     return my @results = $self->get_proxy()->call("unique_functions",$pegs,$user);
747 :     }
748 :    
749 :     sub verify_dir {
750 :     my($self,$dir) = @_;
751 :     return my $result = $self->get_proxy()->call("verify_dir",$dir);
752 :     }
753 :    
754 :     sub reverse_comp {
755 :     my($self,$seq) = @_;
756 :     return my $result = $self->get_proxy()->call("reverse_comp",$seq);
757 :     }
758 :    
759 :     sub rev_comp {
760 :     my($self, $seqP ) = @_;
761 :     return my $result = $self->get_proxy()->call("rev_comp",$seqP);
762 :     }
763 :    
764 :     sub display_id_and_seq {
765 :     my($self,$id, $seq, $fh ) = @_;
766 :     return my $result = $self->get_proxy()->call("display_id_and_seq",$id,$seq,$fh);
767 :     }
768 :    
769 :     sub standard_genetic_code {
770 :    
771 :     my($self) = @_;
772 :    
773 :     my $code = {};
774 :    
775 :     $code->{"AAA"} = "K";
776 :     $code->{"AAC"} = "N";
777 :     $code->{"AAG"} = "K";
778 :     $code->{"AAT"} = "N";
779 :     $code->{"ACA"} = "T";
780 :     $code->{"ACC"} = "T";
781 :     $code->{"ACG"} = "T";
782 :     $code->{"ACT"} = "T";
783 :     $code->{"AGA"} = "R";
784 :     $code->{"AGC"} = "S";
785 :     $code->{"AGG"} = "R";
786 :     $code->{"AGT"} = "S";
787 :     $code->{"ATA"} = "I";
788 :     $code->{"ATC"} = "I";
789 :     $code->{"ATG"} = "M";
790 :     $code->{"ATT"} = "I";
791 :     $code->{"CAA"} = "Q";
792 :     $code->{"CAC"} = "H";
793 :     $code->{"CAG"} = "Q";
794 :     $code->{"CAT"} = "H";
795 :     $code->{"CCA"} = "P";
796 :     $code->{"CCC"} = "P";
797 :     $code->{"CCG"} = "P";
798 :     $code->{"CCT"} = "P";
799 :     $code->{"CGA"} = "R";
800 :     $code->{"CGC"} = "R";
801 :     $code->{"CGG"} = "R";
802 :     $code->{"CGT"} = "R";
803 :     $code->{"CTA"} = "L";
804 :     $code->{"CTC"} = "L";
805 :     $code->{"CTG"} = "L";
806 :     $code->{"CTT"} = "L";
807 :     $code->{"GAA"} = "E";
808 :     $code->{"GAC"} = "D";
809 :     $code->{"GAG"} = "E";
810 :     $code->{"GAT"} = "D";
811 :     $code->{"GCA"} = "A";
812 :     $code->{"GCC"} = "A";
813 :     $code->{"GCG"} = "A";
814 :     $code->{"GCT"} = "A";
815 :     $code->{"GGA"} = "G";
816 :     $code->{"GGC"} = "G";
817 :     $code->{"GGG"} = "G";
818 :     $code->{"GGT"} = "G";
819 :     $code->{"GTA"} = "V";
820 :     $code->{"GTC"} = "V";
821 :     $code->{"GTG"} = "V";
822 :     $code->{"GTT"} = "V";
823 :     $code->{"TAA"} = "*";
824 :     $code->{"TAC"} = "Y";
825 :     $code->{"TAG"} = "*";
826 :     $code->{"TAT"} = "Y";
827 :     $code->{"TCA"} = "S";
828 :     $code->{"TCC"} = "S";
829 :     $code->{"TCG"} = "S";
830 :     $code->{"TCT"} = "S";
831 :     $code->{"TGA"} = "*";
832 :     $code->{"TGC"} = "C";
833 :     $code->{"TGG"} = "W";
834 :     $code->{"TGT"} = "C";
835 :     $code->{"TTA"} = "L";
836 :     $code->{"TTC"} = "F";
837 :     $code->{"TTG"} = "L";
838 :     $code->{"TTT"} = "F";
839 :    
840 :     return $code;
841 :     }
842 :    
843 :     1

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3