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

Annotation of /FigKernelPackages/FIGnet.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : olson 1.2 #
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 : efrank 1.1 package FIGnet;
19 :    
20 :     use Carp;
21 :     use Data::Dumper;
22 :    
23 :     use strict;
24 :     use FIG;
25 :    
26 :     sub new {
27 :     my($class,$url) = @_;
28 :    
29 :     if (! $url)
30 :     {
31 :     my $fig = new FIG;
32 :     bless {
33 :     _fig => $fig,
34 :     }, $class;
35 :     }
36 :     else
37 :     {
38 :     bless { _url => $url }, $class;
39 :     }
40 :     }
41 :    
42 :     sub DESTROY {
43 :     my($self) = @_;
44 :     my($fig);
45 :    
46 :     if ($fig = $self->{_fig})
47 :     {
48 :     $fig->DESTROY;
49 :     }
50 :     }
51 :    
52 :     =pod
53 :    
54 :     =head1 set_remote
55 :    
56 :     usage: $fig->set_remote($url)
57 :    
58 :     Sets the remote version of FIG to the one given by $url.
59 :    
60 :     =cut
61 :    
62 :     sub set_remote_FIG {
63 :     my($self,$url) = @_;
64 :    
65 :     $self->{_url} = $url;
66 :     }
67 :    
68 :    
69 :     =pod
70 :    
71 :     =head1 current_FIG
72 :    
73 :     usage: $url = $fig->current_FIG
74 :    
75 :     Returns the URL of the current FIG ("" for a local copy).
76 :    
77 :     =cut
78 :    
79 :     sub current_FIG {
80 :     my($self) = @_;
81 :    
82 :     return $self->{_url} ? $self->{_url} : "";
83 :     }
84 :    
85 :    
86 :     =pod
87 :    
88 :     =head1 genomes
89 :    
90 :     usage: @genome_ids = $fig->genomes;
91 :    
92 :     Genomes are assigned ids of the form X.Y where X is the taxonomic id maintained by
93 :     NCBI for the species (not the specific strain), and Y is a sequence digit assigned to
94 :     this particular genome (as one of a set with the same genus/species). Genomes also
95 :     have versions, but that is a separate issue.
96 :    
97 :     =cut
98 :    
99 :     sub genomes {
100 :     my($self) = @_;
101 :     my($i);
102 :    
103 :     if ($self->{_fig})
104 :     {
105 :     return $self->{_fig}->genomes;
106 :     }
107 :    
108 :     my $url = $self->{_url} . "/kernel.cgi?request=genomes";
109 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
110 :     my @genomes = ();
111 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
112 :     if ($i < @out)
113 :     {
114 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
115 :     {
116 :     if ($out[$i] =~ /^(\d+\.\d+)/)
117 :     {
118 :     push(@genomes,$1);
119 :     }
120 :     }
121 :     }
122 :     return @genomes;
123 :     }
124 :    
125 :     ############################# KEGG Stuff ####################################
126 :    
127 :    
128 :     =pod
129 :    
130 :     =head1 all_maps
131 :    
132 :     usage: @maps = $fig->all_maps
133 :    
134 :     Returns a list containing all of the KEGG maps that the system knows about (the
135 :     maps need to be periodically updated).
136 :    
137 :     =cut
138 :    
139 :     sub all_maps {
140 :     my($self) = @_;
141 :     my($i);
142 :    
143 :     if ($self->{_fig})
144 :     {
145 :     return $self->{_fig}->all_maps;
146 :     }
147 :    
148 :     my $url = $self->{_url} . "/kernel.cgi?request=all_maps";
149 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
150 :     my @maps = ();
151 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
152 :     if ($i < @out)
153 :     {
154 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
155 :     {
156 :     if ($out[$i] =~ /^(\S+)/)
157 :     {
158 :     push(@maps,$1);
159 :     }
160 :     }
161 :     }
162 :     return @maps;
163 :     }
164 :    
165 :    
166 :     =pod
167 :    
168 :     =head1 map_to_ecs
169 :    
170 :     usage: @ecs = $fig->map_to_ecs($map)
171 :    
172 :     Returns the set of functional roles (usually ECs) that are contained in the functionality
173 :     depicted by $map.
174 :    
175 :     =cut
176 :    
177 :     sub map_to_ecs {
178 :     my($self,$map) = @_;
179 :     my($i);
180 :    
181 :     if ($self->{_fig})
182 :     {
183 :     return $self->{_fig}->map_to_ecs($map);
184 :     }
185 :    
186 :     my $url = $self->{_url} . "/kernel.cgi?request=map_to_ecs($map)";
187 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
188 :     my @ecs = ();
189 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
190 :     if ($i < @out)
191 :     {
192 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
193 :     {
194 :     if ($out[$i] =~ /^(\S+)/)
195 :     {
196 :     push(@ecs,$1);
197 :     }
198 :     }
199 :     }
200 :     return @ecs;
201 :     }
202 :    
203 :    
204 :    
205 :     =pod
206 :    
207 :     =head1 all_compounds
208 :    
209 :     usage: @compounds = $fig->all_compounds
210 :    
211 :     Returns a list containing all of the KEGG compounds.
212 :    
213 :     =cut
214 :    
215 :     sub all_compounds {
216 :     my($self) = @_;
217 :     my($i);
218 :    
219 :     if ($self->{_fig})
220 :     {
221 :     return $self->{_fig}->all_compounds;
222 :     }
223 :    
224 :     my $url = $self->{_url} . "/kernel.cgi?request=all_compounds";
225 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
226 :     my @compounds = ();
227 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
228 :     if ($i < @out)
229 :     {
230 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
231 :     {
232 :     if ($out[$i] =~ /^(\S+)/)
233 :     {
234 :     push(@compounds,$1);
235 :     }
236 :     }
237 :     }
238 :     return @compounds;
239 :     }
240 :    
241 :    
242 :     =pod
243 :    
244 :     =head1 names_of_compounds
245 :    
246 :     usage: @tuples = $fig->names_of_compounds
247 :    
248 :     Returns a list tuples (one per compound). Each tuple contains
249 :    
250 :     [$cid,$names]
251 :    
252 :     where $names is a pointer to a list of the names used for this compound.
253 :    
254 :     =cut
255 :    
256 :     sub names_of_compounds {
257 :     my($self) = @_;
258 :     my($cid,$i,@names);
259 :     my(@all) = ();
260 :    
261 :     if ($self->{_fig})
262 :     {
263 :     foreach $cid ($self->{_fig}->all_compounds)
264 :     {
265 :     push(@all,[$cid,[$self->{_fig}->names_of_compound($cid)]]);
266 :     }
267 :     return @all;
268 :     }
269 :    
270 :     my $url = $self->{_url} . "/kernel.cgi?request=names_of_compounds";
271 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
272 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
273 :     if ($i < @out)
274 :     {
275 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
276 :     {
277 :     if ($out[$i] =~ /^(\S.*\S)/)
278 :     {
279 :     ($cid,@names) = split(/\t/,$1);
280 :     push(@all,[$cid,[@names]]);
281 :     }
282 :     }
283 :     }
284 :     return @all;
285 :     }
286 :    
287 :    
288 :     =pod
289 :    
290 :     =head1 names_of_compound
291 :    
292 :     usage: @names = $fig->names_of_compound
293 :    
294 :     Returns a list containing all of the names assigned to the KEGG compounds. The list
295 :     will be ordered as given by KEGG.
296 :    
297 :     =cut
298 :    
299 :     sub names_of_compound {
300 :     my($self,$cid) = @_;
301 :     my($i);
302 :     my(@names) = ();
303 :    
304 :     if ($self->{_fig})
305 :     {
306 :     return $self->{_fig}->names_of_compound($cid);
307 :     }
308 :    
309 :     my $url = $self->{_url} . "/kernel.cgi?request=names_of_compound($cid)";
310 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
311 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
312 :     if ($i < @out)
313 :     {
314 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
315 :     {
316 :     if ($out[$i] =~ /^(\S.*\S)/)
317 :     {
318 :     push(@names,$1);
319 :     }
320 :     }
321 :     }
322 :     return @names;
323 :     }
324 :    
325 :    
326 :     =pod
327 :    
328 :     =head1 comp2react
329 :    
330 :    
331 :     usage: @rids = $fig->comp2react($cid)
332 :    
333 :     Returns a list containing all of the reaction IDs for reactions that take $cid
334 :     as either a substrate or a product.
335 :    
336 :     =cut
337 :    
338 :     sub comp2react {
339 :     my($self,$cid) = @_;
340 :     my($i);
341 :     my(@rids) = ();
342 :    
343 :     if ($self->{_fig})
344 :     {
345 :     return $self->{_fig}->comp2react($cid);
346 :     }
347 :    
348 :     my $url = $self->{_url} . "/kernel.cgi?request=comp2react($cid)";
349 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
350 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
351 :     if ($i < @out)
352 :     {
353 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
354 :     {
355 :     if ($out[$i] =~ /^(\S.*\S)/)
356 :     {
357 :     push(@rids,$1);
358 :     }
359 :     }
360 :     }
361 :     return @rids;
362 :     }
363 :    
364 :    
365 :     =pod
366 :    
367 :     =head1 all_reactions
368 :    
369 :     usage: @rids = $fig->all_reactions
370 :    
371 :     Returns a list containing all of the KEGG reaction IDs.
372 :    
373 :     =cut
374 :    
375 :     sub all_reactions {
376 :     my($self) = @_;
377 :     my($i);
378 :    
379 :     if ($self->{_fig})
380 :     {
381 :     return $self->{_fig}->all_reactions;
382 :     }
383 :    
384 :     my $url = $self->{_url} . "/kernel.cgi?request=all_reactions";
385 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
386 :     my @reactions = ();
387 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
388 :     if ($i < @out)
389 :     {
390 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
391 :     {
392 :     if ($out[$i] =~ /^(\S+)/)
393 :     {
394 :     push(@reactions,$1);
395 :     }
396 :     }
397 :     }
398 :     return @reactions;
399 :     }
400 :    
401 :    
402 :     =pod
403 :    
404 :     =head1 reversible
405 :    
406 :     usage: $rev = $fig->reversible($rid)
407 :    
408 :     Returns true iff the reactions had a "main direction" designated as "<=>";
409 :    
410 :     =cut
411 :    
412 :     sub reversible {
413 :     my($self,$rid) = @_;
414 :     my($i);
415 :    
416 :     if ($self->{_fig})
417 :     {
418 :     return $self->{_fig}->reversible($rid);
419 :     }
420 :    
421 :     my $url = $self->{_url} . "/kernel.cgi?request=reversible($rid)";
422 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
423 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
424 :     if ($i < @out)
425 :     {
426 :     if ($out[$i+1] =~ /^([01])/)
427 :     {
428 :     return $1;
429 :     }
430 :     }
431 :     return 0;
432 :     }
433 :    
434 :    
435 :     =pod
436 :    
437 :     =head1 catalyzed_by
438 :    
439 :     usage: @ecs = $fig->catalyzed_by($rid)
440 :    
441 :     Returns the ECs that are reputed to catalyze the reaction. Note that we are currently
442 :     just returning the ECs that KEGG gives. We need to handle the incompletely specified forms
443 :     (e.g., 1.1.1.-), but we do not do it yet.
444 :    
445 :     =cut
446 :    
447 :     sub catalyzed_by {
448 :     my($self,$rid) = @_;
449 :     my($i);
450 :    
451 :     if ($self->{_fig})
452 :     {
453 :     return $self->{_fig}->catalyzed_by($rid);
454 :     }
455 :    
456 :     my @tuples = ();
457 :     my $url = $self->{_url} . "/kernel.cgi?request=catalyzed_by($rid)";
458 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
459 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
460 :     if ($i < @out)
461 :     {
462 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
463 :     {
464 :     if ($out[$i] =~ /^(\S.*\S)/)
465 :     {
466 :     push(@tuples,$1);
467 :     }
468 :     }
469 :     }
470 :     return @tuples;
471 :     }
472 :    
473 :    
474 :     =pod
475 :    
476 :     =head1 catalyzes
477 :    
478 :     usage: @ecs = $fig->catalyzes($role)
479 :    
480 :     Returns the rids of the reactions catalyzed by the "role" (normally an EC).
481 :    
482 :     =cut
483 :    
484 :     sub catalyzes {
485 :     my($self,$role) = @_;
486 :     my($i);
487 :    
488 :     if ($self->{_fig})
489 :     {
490 :     return $self->{_fig}->catalyzes($role);
491 :     }
492 :    
493 :     my @rids = ();
494 :     my $url = $self->{_url} . "/kernel.cgi?request=catalyzes($role)";
495 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
496 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
497 :     if ($i < @out)
498 :     {
499 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
500 :     {
501 :     if ($out[$i] =~ /^(R\d+)/)
502 :     {
503 :     push(@rids,$1);
504 :     }
505 :     }
506 :     }
507 :     return @rids;
508 :     }
509 :    
510 :     sub reaction2comp {
511 :     my($self,$rid,$which) = @_;
512 :     my($i);
513 :     my(@tuples) = ();
514 :    
515 :     if ($self->{_fig})
516 :     {
517 :     return $self->{_fig}->reaction2comp($rid,$which);
518 :     }
519 :    
520 :     my $url = $self->{_url} . "/kernel.cgi?request=reaction2comp($rid,$which)";
521 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
522 :     for ($i=0; ($i < @out) && ($out[$i] !~ /^<pre>/i); $i++) {}
523 :     if ($i < @out)
524 :     {
525 :     for ($i++; ($i < @out) && ($out[$i] !~ /^</); $i++)
526 :     {
527 :     if ($out[$i] =~ /^(\S.*\S)/)
528 :     {
529 :     push(@tuples,[split(/\t/,$1)]);
530 :     }
531 :     }
532 :     }
533 :     return @tuples;
534 :     }
535 :    
536 :     sub seqs_with_roles_in_genomes {
537 :     my($self,$genomes,$roles,$who) = @_;
538 :     my($line,$genome,$role,$peg,$func);
539 :    
540 :     my $result = {};
541 :     if ($self->{_fig})
542 :     {
543 :     return $self->{_fig}->seqs_with_roles_in_genomes($genomes,$roles,$who);
544 :     }
545 :    
546 :     my $genomesL = join(",",@$genomes);
547 :     my $rolesL = join(",",@$roles);
548 :     my $url = $self->{_url} . "/kernel.cgi?request=seqs_with_roles_in_genomes([$genomesL],[$rolesL],$who)";
549 :     my @out = `wget -O - \'$url\' 2> /dev/null`;
550 :     foreach $line (@out)
551 :     {
552 :     chop $line;
553 :     ($genome,$role,$peg,$func) = split(/\t/,$line);
554 :     push(@{$result->{$genome}->{$role}},[$peg,$func]);
555 :     }
556 :     return $result;
557 :     }
558 :    
559 :     1

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3