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

Annotation of /FigKernelPackages/FIGrpc.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3