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

Annotation of /FigKernelPackages/FIGnet.pm

Parent Directory Parent Directory | Revision Log Revision Log


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

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

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3