Bio-KBase
view release on metacpan or search on metacpan
lib/Bio/KBase/CDMI/Client.pm view on Meta::CPAN
}
=head2 $result = protein_families_to_functions(protein_families)
protein_families_to_functions can be used to extract the set of functions assigned to the fids
that make up the family. Each input protein_family is mapped to a family function.
=cut
sub protein_families_to_functions
{
my($self, @args) = @_;
if ((my $n = @args) != 1)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function protein_families_to_functions (received $n, expecting 1)");
}
{
my($protein_families) = @args;
my @_bad_arguments;
(ref($protein_families) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 1 \"protein_families\" (value was \"$protein_families\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to protein_families_to_functions:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'protein_families_to_functions');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_API.protein_families_to_functions",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'protein_families_to_functions',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method protein_families_to_functions",
status_line => $self->{client}->status_line,
method_name => 'protein_families_to_functions',
);
}
}
=head2 $result = protein_families_to_co_occurring_families(protein_families)
Since we accumulate data relating to the co-occurrence (i.e., chromosomal
clustering) of genes in prokaryotic genomes, we can note which pairs of genes tend to co-occur.
From this data, one can compute the protein families that tend to co-occur (i.e., tend to
cluster on the chromosome). This allows one to formulate conjectures for unclustered pairs, based
on clustered pairs from the same protein_families.
=cut
sub protein_families_to_co_occurring_families
{
my($self, @args) = @_;
if ((my $n = @args) != 1)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function protein_families_to_co_occurring_families (received $n, expecting 1)");
}
{
my($protein_families) = @args;
my @_bad_arguments;
(ref($protein_families) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 1 \"protein_families\" (value was \"$protein_families\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to protein_families_to_co_occurring_families:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'protein_families_to_co_occurring_families');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_API.protein_families_to_co_occurring_families",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'protein_families_to_co_occurring_families',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method protein_families_to_co_occurring_families",
status_line => $self->{client}->status_line,
method_name => 'protein_families_to_co_occurring_families',
);
}
}
=head2 $result = co_occurrence_evidence(pairs_of_fids)
co-occurence_evidence is used to retrieve the detailed pairs of genes that go into the
computation of co-occurence scores. The scores reflect an estimate of the number of distinct OTUs that
contain an instance of a co-occuring pair. This routine returns as evidence a list of all the pairs that
went into the computation.
The input to the computation is a list of pairs for which evidence is desired.
The returned output is a list of elements. one for each input pair. Each output element
is a 2-tuple: the input pair and the evidence for the pair. The evidence is a list of pairs of
fids that are believed to correspond to the input pair.
lib/Bio/KBase/CDMI/Client.pm view on Meta::CPAN
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.all_entities_Complex",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'all_entities_Complex',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method all_entities_Complex",
status_line => $self->{client}->status_line,
method_name => 'all_entities_Complex',
);
}
}
=head2 $result = get_entity_Compound(ids, fields)
A compound is a chemical that participates in a reaction. Both
ligands and reaction components are treated as compounds.
It has the following fields:
=over 4
=item label
primary name of the compound, for use in displaying
reactions
=item abbr
shortened abbreviation for the compound name
=item msid
common modeling ID of this compound
=item ubiquitous
TRUE if this compound is found in most reactions, else FALSE
=item mod_date
date and time of the last modification to the
compound definition
=item uncharged_formula
a electrically neutral formula for the compound
=item formula
a pH-neutral formula for the compound
=item mass
atomic mass of the compound
=back
=cut
sub get_entity_Compound
{
my($self, @args) = @_;
if ((my $n = @args) != 2)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function get_entity_Compound (received $n, expecting 2)");
}
{
my($ids, $fields) = @args;
my @_bad_arguments;
(ref($ids) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 1 \"ids\" (value was \"$ids\")");
(ref($fields) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 2 \"fields\" (value was \"$fields\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to get_entity_Compound:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'get_entity_Compound');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.get_entity_Compound",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'get_entity_Compound',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method get_entity_Compound",
status_line => $self->{client}->status_line,
method_name => 'get_entity_Compound',
);
}
}
=head2 $result = query_entity_Compound(qry, fields)
lib/Bio/KBase/CDMI/Client.pm view on Meta::CPAN
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'all_entities_Publication');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.all_entities_Publication",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'all_entities_Publication',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method all_entities_Publication",
status_line => $self->{client}->status_line,
method_name => 'all_entities_Publication',
);
}
}
=head2 $result = get_entity_Reaction(ids, fields)
A reaction is a chemical process that converts one set of
compounds (substrate) to another set (products).
It has the following fields:
=over 4
=item mod_date
date and time of the last modification to this reaction's
definition
=item name
descriptive name of this reaction
=item msid
common modeling ID of this reaction
=item abbr
abbreviated name of this reaction
=item equation
displayable formula for the reaction
=item reversibility
direction of this reaction (> for forward-only,
< for backward-only, = for bidirectional)
=back
=cut
sub get_entity_Reaction
{
my($self, @args) = @_;
if ((my $n = @args) != 2)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function get_entity_Reaction (received $n, expecting 2)");
}
{
my($ids, $fields) = @args;
my @_bad_arguments;
(ref($ids) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 1 \"ids\" (value was \"$ids\")");
(ref($fields) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 2 \"fields\" (value was \"$fields\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to get_entity_Reaction:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'get_entity_Reaction');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.get_entity_Reaction",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'get_entity_Reaction',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method get_entity_Reaction",
status_line => $self->{client}->status_line,
method_name => 'get_entity_Reaction',
);
}
}
=head2 $result = query_entity_Reaction(qry, fields)
lib/Bio/KBase/CDMI/Client.pm view on Meta::CPAN
if ((my $n = @args) != 3)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function all_entities_ReactionRule (received $n, expecting 3)");
}
{
my($start, $count, $fields) = @args;
my @_bad_arguments;
(!ref($start)) or push(@_bad_arguments, "Invalid type for argument 1 \"start\" (value was \"$start\")");
(!ref($count)) or push(@_bad_arguments, "Invalid type for argument 2 \"count\" (value was \"$count\")");
(ref($fields) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 3 \"fields\" (value was \"$fields\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to all_entities_ReactionRule:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'all_entities_ReactionRule');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.all_entities_ReactionRule",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
method_name => 'all_entities_ReactionRule',
);
} else {
return wantarray ? @{$result->result} : $result->result->[0];
}
} else {
Bio::KBase::Exceptions::HTTP->throw(error => "Error invoking method all_entities_ReactionRule",
status_line => $self->{client}->status_line,
method_name => 'all_entities_ReactionRule',
);
}
}
=head2 $result = get_entity_Reagent(ids, fields)
This entity represents a compound as it is used by
a specific reaction. A reaction involves many compounds, and a
compound can be involved in many reactions. The reagent
describes the use of the compound by a specific reaction.
It has the following fields:
=over 4
=item stoichiometry
Number of molecules of the compound that participate
in a single instance of the reaction. For example, if a
reaction produces two water molecules, the stoichiometry of
water for the reaction would be two. When a reaction is
written on paper in chemical notation, the stoichiometry is
the number next to the chemical formula of the
compound. The value is negative for substrates and positive
for products.
=item cofactor
TRUE if the compound is a cofactor; FALSE if it is a major
component of the reaction.
=item compartment_index
Abstract number that groups this reagent into a
compartment. Each group can then be assigned to real
compartments when doing comparative analysis.
=item transport_coefficient
Number of reagents of this type transported.
A positive value implies transport into the reactions
default compartment; a negative value implies export
to the reagent's specified compartment.
=back
=cut
sub get_entity_Reagent
{
my($self, @args) = @_;
if ((my $n = @args) != 2)
{
Bio::KBase::Exceptions::ArgumentValidationError->throw(error =>
"Invalid argument count for function get_entity_Reagent (received $n, expecting 2)");
}
{
my($ids, $fields) = @args;
my @_bad_arguments;
(ref($ids) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 1 \"ids\" (value was \"$ids\")");
(ref($fields) eq 'ARRAY') or push(@_bad_arguments, "Invalid type for argument 2 \"fields\" (value was \"$fields\")");
if (@_bad_arguments) {
my $msg = "Invalid arguments passed to get_entity_Reagent:\n" . join("", map { "\t$_\n" } @_bad_arguments);
Bio::KBase::Exceptions::ArgumentValidationError->throw(error => $msg,
method_name => 'get_entity_Reagent');
}
}
my $result = $self->{client}->call($self->{url}, {
method => "CDMI_EntityAPI.get_entity_Reagent",
params => \@args,
});
if ($result) {
if ($result->is_error) {
Bio::KBase::Exceptions::JSONRPC->throw(error => $result->error_message,
code => $result->content->{code},
( run in 1.081 second using v1.01-cache-2.11-cpan-39bf76dae61 )