X
: other
This document is a placeholder for the language-specific documentation
for X
.
Treebank Statistics (UD_Croatian)
There are 165 X
lemmas (2%), 169 X
types (1%) and 253 X
tokens (0%).
Out of 14 observed tags, the rank of X
is: 7 in number of lemmas, 8 in number of types and 14 in number of tokens.
The 10 most frequent X
lemmas: de, A1, European, SETimes, Southeast, Times, bin, freedom, house, world
The 10 most frequent X
types: de, A1, European, Southeast, bin, Freedom, SETimes, Times, world, Press
The 10 most frequent ambiguous lemmas: SETimes (PROPN 104, X 6), Times (X 6, PROPN 2), International (X 4, PROPN 1), DUI (PROPN 3, X 2), New (X 2, PROPN 1), Stripes (X 2, PROPN 1), Vision (X 2, PROPN 1), White (X 2, PROPN 1), rock (X 2, ADJ 1), AKP (PROPN 9, X 1)
The 10 most frequent ambiguous types: SETimes (PROPN 102, X 5), International (X 2, PROPN 1), New (X 2, PROPN 1), Stripes (X 2, PROPN 1), Vision (X 2, PROPN 1), White (X 2, PROPN 1), rock (X 2, ADJ 1), AKP (PROPN 7, X 1), Anadolu (X 1, PROPN 1), Bush (PROPN 7, X 1)
- SETimes
- International
- New
- Stripes
- Vision
- White
- rock
- AKP
- Anadolu
- X 1: Skupina turskih znanstvenika otkrila je vrstu planinske gazele koja nikad do sad nije bila viđena u Turskoj , izvijestila je 6. ožujka tiskovna Anadolu .
- PROPN 1: Istanbul , u Turskoj , bit će 13. i 14. lipnja domaćin četvrtog Međunarodnog kongresa o NLO-ima i Novom dobu , izvijestila je u srijedu ( 3. lipnja ) tiskovna agencija Anadolu .
- Bush
Morphology
The form / lemma ratio of X
is 1.024242 (the average of all parts of speech is 1.870216).
The 1st highest number of forms (2) was observed with the lemma “DUI”: DUI, DUI-a.
The 2nd highest number of forms (2) was observed with the lemma “House”: House, Housea.
The 3rd highest number of forms (2) was observed with the lemma “International”: International, Internationala.
X
does not occur with any features.
Relations
X
nodes are attached to their parents using 16 different relations: hr-dep/compound (99; 39% instances), hr-dep/appos (35; 14% instances), hr-dep/nmod (28; 11% instances), hr-dep/name (20; 8% instances), hr-dep/nsubj (17; 7% instances), hr-dep/conj (12; 5% instances), hr-dep/amod (10; 4% instances), hr-dep/parataxis (8; 3% instances), hr-dep/case (7; 3% instances), hr-dep/foreign (6; 2% instances), hr-dep/nsubjpass (4; 2% instances), hr-dep/advmod (2; 1% instances), hr-dep/dobj (2; 1% instances), hr-dep/mark (1; 0% instances), hr-dep/nummod (1; 0% instances), hr-dep/punct (1; 0% instances)
Parents of X
nodes belong to 8 different parts of speech: X (90; 36% instances), NOUN (85; 34% instances), PROPN (44; 17% instances), VERB (25; 10% instances), ADJ (5; 2% instances), NUM (2; 1% instances), ADV (1; 0% instances), PRON (1; 0% instances)
151 (60%) X
nodes are leaves.
54 (21%) X
nodes have one child.
27 (11%) X
nodes have two children.
21 (8%) X
nodes have three or more children.
The highest child degree of a X
node is 17.
Children of X
nodes are attached using 14 different relations: hr-dep/compound (87; 39% instances), hr-dep/punct (58; 26% instances), hr-dep/conj (20; 9% instances), hr-dep/name (15; 7% instances), hr-dep/case (11; 5% instances), hr-dep/cc (8; 4% instances), hr-dep/appos (5; 2% instances), hr-dep/amod (4; 2% instances), hr-dep/foreign (4; 2% instances), hr-dep/nmod (3; 1% instances), hr-dep/acl (2; 1% instances), hr-dep/parataxis (2; 1% instances), hr-dep/discourse (1; 0% instances), hr-dep/remnant (1; 0% instances)
Children of X
nodes belong to 10 different parts of speech: X (90; 41% instances), PUNCT (58; 26% instances), PROPN (27; 12% instances), NOUN (13; 6% instances), ADP (12; 5% instances), CONJ (8; 4% instances), ADJ (7; 3% instances), VERB (3; 1% instances), SCONJ (2; 1% instances), PRON (1; 0% instances)
X in other languages: [bg] [cs] [de] [el] [en] [es] [eu] [fa] [fi] [fr] [ga] [he] [hu] [it] [ja] [ko] [sv] [u]


Mogoeng: It's a shame inequality has become sharper during constitutional democracy
by Jeanette ChabalalaChief Justice Mogoeng Mogoeng says it's a shame that inequality in South Africa has become "sharper" during a constitutional democracy.
Delivering the 17th annual Nelson Mandela Lecture at the University of Johannesburg's Soweto campus on Saturday, Mogoeng said: "It really is a shame that 25 years down the line we still have so much of our people suffering as they do."
"It is a shame that inequality has become sharper during constitutional democracy. We need unity now more than before," Mogoeng said in his keynote address.
"We will be betraying the legacy of Madiba if we don't give practical expression to the injustices of our past"
He spoke under the theme: "Constitutionalism as a tool for transformation."
"We will be betraying the legacy of Madiba if we don't give practical expression to the injustices of our past."
He also said each citizen had the responsibility to build the country and that people should not waste time polarising society.
"Let's confront and expose any institution and anybody who practices discrimination."
The chief justice said most of the country's problems were a direct consequence of colonialism and apartheid.
"Anybody who says don't blame anything on colonialism and apartheid is being mischievous. Most of the problems we have to deal with right now are a consequence of colonialism and apartheid. It's critical that we never stop talking about it. What we cannot do is blame it all on colonialism and apartheid.
"It is therefore absolutely necessary that we never stop talking about colonialism...and apartheid."
Mogoeng called on South Africans to unite, adding that "unity is essential for what Madiba calls 'the vision enshrined in the Constitution'."


Fitting routines¶
- GOAL:
Step through bins (spectra) and calculate the temperature value of each bin using XSPEC
- OUTPUTS:
A file which contains the bin number and associated temperature and reduced chi-squared
- ADDITIONAL NOTES:
Be sure to run heainit first
-
TemperatureMapPipeline.Fits.
FitXSPEC
(spectrum_files, background_files, redshift, n_H, temp_guess, grouping, spec_count, plot_dir, errors=False)¶ Fit observations simultaneously using models defined in obsid_set().
- Parameters
spectrum_files (list) – List of spectrum files (i.e. [‘obs1.pi’, ‘obs2.pi’])
background_files (list) – List of background files (i.e. [‘obs1_bkg.pi’, ‘obs2_bkg.pi’])
redshift (float) – Cosmological Redshift of Object
n_H (float) – Column Density in direction of object – units of 10^{-22} cm^{-2}
Temp_guess (float) – Estimate of Temperature Value
grouping (int) – Number of counts per bin (i.e. 5)
spec_count (int) – Local number of spectra with reference to the total number of spectra being fitted
plot_dir (str) – Path to directory containing plots
- Kwargs:
errors (bool): Boolean to calculate 1-sigma errors (default=False)
- Returns
Fitted Temperature Value in keV Temp_min: Minimum Fitted Temperature Value at 1-sigma in keV Temp_max: Maximum Fitted Temperature Value at 1-sigma in keV Abundance: Fitted Abundance Value in Z_{solar} Ab_min: Minimum Fitted Abundance Value at 1-sigma in Z_{solar} Ab_max: Maximum Fitted Abundance Value at 1-sigma in Z_{solar} Norm: Fitted Normalization Value Norm_min: Minimum Fitted Normalization Value at 1-sigma norm_max: Maximum Fitted Normalization Value at 1-sigma reduced_chi_sq: Reduced Chi Square Value for the Fit Flux: Fitted Flux Value in ergs/s/cm^{-2} Flux_min: Minimum Flux Value in ergs/s/cm^{-2} Flux_max: Maximum Flux Value in ergs/s/cm^{-2}
- Return type
Temperature
Note
If the fits are taking too long, set errors=False. The min and max value will just be copies of the fitted value.
Flux errors are always calculated
-
TemperatureMapPipeline.Fits.
Fitting
(base_directory, dir, file_name, num_files, redshift, n_H, temp_guess, output_file, bin_spec_dir)¶ Fit each region’s spectra and create a text file containing the spectral fit information for each bin :param base_directory: Path to main Directory :param dir: ObsID :param file_name: Root name of PI/PHA file :param num_files: Number of spatial bins :param redshift: Redshift of cluster :param n_H: Column density :param temp_guess: Initial temperature guess :param output_file: Text file containing each bin’s spectral fit information :param bin_spec_dir: Path to extracted spectra for each bin within an ObsID
- Returns
None
-
TemperatureMapPipeline.Fits.
concat_temp_data
(num_spec, output_file)¶ Concatenate temperature information. Used if running on several processors :param num_spec: Number of spectra (or bins) :param output_file: File name of final concatenated temperature data
-
TemperatureMapPipeline.Fits.
fit_loop
(dir, bin_spec_dir, file_name, redshift, n_H, temp_guess, grouping, plot_dir, base_directory, i)¶ Loop for fitting spectra. This will simply call the FitXSPEC function and write out the results to a temporary file
- Parameters
bin_spec_dir – Path to extracted spectra for each bin within an ObsID
dir (str) – ObsID
file_name (str) – Root name of PI/PHA file
redshift (float) – Cosmological Redshift of Object
n_H (float) – Column Density in direction of object – units of 10^{-22} cm^{-2}
Temp_guess (float) – Estimate of Temperature Value
grouping (int) – Number of counts per bin (i.e. 5)
plot_dir (str) – Path to plots
base_directory (str) – Path to main Directory
i (int) – Relative spectrum number
- Returns
None
-
TemperatureMapPipeline.Fits.
obsid_set
(src_model_dict, bkg_model_dict, obsid, bkg_spec, obs_count, redshift, nH_val, Temp_guess)¶ Set the observations’ model using an absorbed apec model. Each observation will be tied with the other to allow simultaneous fitting.
We additionally apply a background model.
- It contains two (frozen) thermal emission pieces:
unabsorbed apec model with kT=0.18 keV
absorbed bremmstrahlung emission with kT=40 keV
- Parameters
src_model_dict (dict) – Dictionary of source models – Created in FitXSPEC()
bkg_model_dict (dict) – Dictionary of background models – Created in FitXSPEC()
obsid (str) – Current Chandra ObsID
bkg_spec (str) – Background file corresponding to ObsID
obs_ct (int) – Relative ObsID number
redshift (float) – Cosmological Redshift of Object
nH_val (float) – Column Density in direction of object – units of 10^{-22} cm^{-2}
Temp_guess (float) – Estimate of Temperature Value
- Returns
Updated src_model_dict and bkg_model_dict


Home
Events
Box Office
Facilities
Directions
Contact Us
Links
Links
stageplays
CPST-2400 Assignments
Antoine's Site
Kazuaki's Site
Drakes's Site
Playrights
Broadway Plays
New York Theater Guide
Free Play Scripts
Washington Post Play Reviews


Welcome to the Employee Network, your one-stop-shop for managing your projects and accounts, and keeping up-to-date with the Company.


More hacking on station lists tonight. So far it’s been as easy as I hoped, once I created a reliable way to watch all Pandora traffic (through NSURLProtocols). The station list comes back as an XML document, and I can copy that off into an easy array for later use. The only thing I need to work more on is QuickMix management, since those are magically pulled out of the main channel list, and I should probably do the same to avoid confusion.
I’ve talked often with folks about XML and how there are so many good ways to compress it quite effectively and it’s strange that XML developers have chosen not to do that. Rather, real XML winds up being insanely verbose and bloated on the wire. I hereby take back my earlier complaints. The fact that I can read XML by sniffing the traffic without having to apply any decoding (not even gunzip), and can recognize XML easily when I come across it, is one of the biggest boons to reverse engineering I’ve ever encountered. Long live human readable data formats!


Assignment
Menu
Manufacturer
Model
Inventory
Car Inventory System
Manufacturer
Name
{{validatedString}}
Copyright © Assignment by Jenil Sanghvi


CDMI_API
The CDMI_API defines the component of the KBase API that supports interaction with instances of the CDM (Central Data Model). A basic familiarity with these routines will allow the user to extract data from the CS (Central Store). We anticipate supporting numerous sparse CDMIs in the PS (Persistent Store).
There are several broad categories of routines supported in the CDMI-API.
The simplest is set of "get entity" routines -- each returning data extracted from instances of a single entity type. These routines all take as input a list of ids referencing instances of a single type of entity. They construct as output a mapping which takes as input an id and associates as output a set of fields from that instance of the entity. Each routine allows the user to specify which fields are desired.
For example, assume you have an input file "Staphylococci," which is a list of genome IDs for each species of Staphylococcus in the database. The get_entity_Genome command is used to retrieve detailed information about each genome in the file. By using different modifiers, you can specify what kind of information you want to display. In this example, the modifier "contigs" was used. Thus, the number next to the genome ID in the output file indicates the number of contigs each Staphylococcus genome has. For a list of available modifiers relating to each identity, please refer to the ER model.
> / cat Staphylococci | cut -f 1 | get_entity_Genome - f contigs
kb|g.134 2
kb|g.636 1
kb|g.2506 15
kb|g.9303 1
kb|g.3801 87
kb|g.2025 46
kb|g.2516 13
kb|g.2603 33
kb|g.19928 2
kb|g.1852 131
kb|g.8476 1
kb|g.2742 46
To use these routines effectively, a user will need to gradually become familiar with the entities supported in the CDM. We suggest perusing the entity-relationship model that underlies the CDM to get a good introduction.
The next simplest set of routines provide the "get relationship" routines. These take as input a list of ids for a specific entity type, and the give access to the relationship nodes associated with each entity. Thus, get_relationship_WasSubmittedBy takes the input genome ID and outputs the ID with an added column showing the source of that particular genome. It is essential to be able to navigate the ER model to successfully implement these commands, since not all relationship types are applicable to each entity.
> / echo 'kb|g.0' | get_relationship_WasSubmittedBy -to id
kb|g.0 SEED
Of the remaining CDMI-API routines, most are used to extract data by "crossing one or more relationships". Thus,
my $references = $kbO->fids_to_literature($fids)
takes as input a list of feature ids referenced by the variable $fids. It creates a hash ($references) which maps each input key to a list of literature references. The construction of the literature references for a given ID involves crossing relationships from the entity 'Feature' to 'ProteinSequence' to 'Publication'. We have attempted to package this specific search in a convenient form. We anticipate that the number of queries of this last class will grow (especially as new entities are added to the model).
A majority of the CS-API routines take a list of ids as input. Each id may be thought of as input to a query that produces an output result. We support processing an input list, since the performance (which is usually governed by network interactions) is much better if you process a batch of items, rather than invoking the API repeatedly for each of the ids. Normally, the output would be a mapping (a hash for Perl versions) from the input ids to the output results. Thus, a routine like
fids_to_literature
will take a list of feature ids as input. The returned value will be a mapping from feature ids (fids) to publication references.
It is a little inconvenient to batch your requests by supplying a list of fids, but the performance will be much better in most cases. Please note that you are controlling the granularity of each request, and in most cases the size of the input list is not critical. However, you should note that while batching up hundreds or thousands of input ids at a time should work just fine, millions may well cause things to break (e.g., you may exhaust local memory in your machine as the output results are returned). As machines get larger, the appropriate size of the input lists may become largely irrelevant. For now, we recommend that you experiment a bit and use common sense.
$return = $obj->fids_to_annotations($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is an annotations fids is a reference to a list where each element is a fid fid is a string annotations is a reference to a list where each element is an annotation annotation is a reference to a list containing 3 items: 0: a comment 1: an annotator 2: an annotation_time comment is a string annotator is a string annotation_time is an int
This routine takes as input a list of fids. It retrieves the existing annotations for each fid, including the text of the annotation, who made the annotation and when (as seconds from the epoch).
$return = $obj->fids_to_functions($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a function fids is a reference to a list where each element is a fid fid is a string function is a string
This routine takes as input a list of fids and returns a mapping from the fids to their assigned functions.
$return = $obj->fids_to_literature($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a pubrefs fids is a reference to a list where each element is a fid fid is a string pubrefs is a reference to a list where each element is a pubref pubref is a reference to a list containing 3 items: 0: (id) a string 1: (link) a string 2: (title) a string
We try to associate features and publications, when the publications constitute supporting evidence of the function. We connect a paper to a feature when we believe that an "expert" has asserted that the function of the feature is basically what we have associated with the feature. Thus, we might attach a paper reporting the crystal structure of a protein, even though the paper is clearly not the paper responsible for the original characterization. Our position in this matter is somewhat controversial, but we are seeking to characterize some assertions as relatively solid, and this strategy seems to support that goal. Please note that we certainly wish we could also capture original publications, and when experts can provide those connections, we hope that they will help record the associations.
$return = $obj->fids_to_protein_families($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a protein_families fids is a reference to a list where each element is a fid fid is a string protein_families is a reference to a list where each element is a protein_family protein_family is a string
KBase supports the creation and maintence of protein families. Each family is intended to contain a set of isofunctional homologs. Currently, the families are collections of translations of features, rather than of just protein sequences (represented by md5s, for example). fids_to_protein_families supports access to the features that have been grouped into a family. Ideally, each feature in a family would have the same assigned function. This is not always true, but probably should be.
$return = $obj->fids_to_roles($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a roles fids is a reference to a list where each element is a fid fid is a string roles is a reference to a list where each element is a role role is a string
Given a feature, one can get the set of roles it implements using fid_to_roles. Remember, a protein can be multifunctional -- implementing several roles. This can occur due to fusions or to broad specificity of substrate.
$return = $obj->fids_to_subsystems($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a subsystems fids is a reference to a list where each element is a fid fid is a string subsystems is a reference to a list where each element is a subsystem subsystem is a string
fids in subsystems normally have somewhat more reliable assigned functions than those not in subsystems. Hence, it is common to ask "Is this protein-encoding gene included in any subsystems?" fids_to_subsystems can be used to see which subsystems contain a fid (or, you can submit as input a set of fids and get the subsystems for each).
$return = $obj->fids_to_co_occurring_fids($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a scored_fids fids is a reference to a list where each element is a fid fid is a string scored_fids is a reference to a list where each element is a scored_fid scored_fid is a reference to a list containing 2 items: 0: a fid 1: (score) a float
One of the most powerful clues to function relates to conserved clusters of genes on the chromosome (in prokaryotic genomes). We have attempted to record pairs of genes that tend to occur close to one another on the chromosome. To meaningfully do this, we need to construct similarity-based mappings between genes in distinct genomes. We have constructed such mappings for many (but not all) genomes maintained in the KBase CS. The prokaryotic geneomes in the CS are grouped into OTUs by ribosomal RNA (genomes within a single OTU have SSU rRNA that is greater than 97% identical). If two genes occur close to one another (i.e., corresponding genes occur close to one another), then we assign a score, which is the number of distinct OTUs in which such clustering is detected. This allows one to normalize for situations in which hundreds of corresponding genes are detected, but they all come from very closely related genomes.
The significance of the score relates to the number of genomes in the database. We recommend that you take the time to look at a set of scored pairs and determine approximately what percentage appear to be actually related for a few cutoff values.
$return = $obj->fids_to_locations($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a location fids is a reference to a list where each element is a fid fid is a string location is a reference to a list where each element is a region_of_dna region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int
A "location" is a sequence of "regions". A region is a contiguous set of bases in a contig. We work with locations in both the string form and as structures. fids_to_locations takes as input a list of fids. For each fid, a structured location is returned. The location is a list of regions; a region is given as a pointer to a list containing
the contig,
the beginning base in the contig (from 1).
the strand (+ or -), and
the length
Note that specifying a region using these 4 values allows you to represent a single base-pair region on either strand unambiguously (which giving begin/end pairs does not achieve).
$return = $obj->locations_to_fids($region_of_dna_strings)
$region_of_dna_strings is a region_of_dna_strings $return is a reference to a hash where the key is a region_of_dna_string and the value is a fids region_of_dna_strings is a reference to a list where each element is a region_of_dna_string region_of_dna_string is a string fids is a reference to a list where each element is a fid fid is a string
It is frequently the case that one wishes to look up the genes that occur in a given region of a contig. Location_to_fids can be used to extract such sets of genes for each region in the input set of regions. We define a gene as "occuring" in a region if the location of the gene overlaps the designated region.
$return = $obj->alleles_to_bp_locs($alleles)
$alleles is an alleles $return is a reference to a hash where the key is an allele and the value is a bp_loc alleles is a reference to a list where each element is an allele allele is a string bp_loc is a reference to a list containing 2 items: 0: a contig 1: (position) an int contig is a string
$return = $obj->region_to_fids($region_of_dna)
$region_of_dna is a region_of_dna $return is a fids region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int fids is a reference to a list where each element is a fid fid is a string
$return = $obj->region_to_alleles($region_of_dna)
$region_of_dna is a region_of_dna $return is a reference to a list where each element is a reference to a list containing 2 items: 0: an allele 1: (position) an int region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int allele is a string
$return = $obj->alleles_to_traits($alleles)
$alleles is an alleles $return is a reference to a hash where the key is an allele and the value is a traits alleles is a reference to a list where each element is an allele allele is a string traits is a reference to a list where each element is a trait trait is a string
$return = $obj->traits_to_alleles($traits)
$traits is a traits $return is a reference to a hash where the key is a trait and the value is an alleles traits is a reference to a list where each element is a trait trait is a string alleles is a reference to a list where each element is an allele allele is a string
$return = $obj->ous_with_trait($genome, $trait, $measurement_type, $min_value, $max_value)
$genome is a genome $trait is a trait $measurement_type is a measurement_type $min_value is a float $max_value is a float $return is a reference to a list where each element is a reference to a list containing 2 items: 0: an ou 1: a measurement_value genome is a string trait is a string measurement_type is a string ou is a string measurement_value is a float
$dna_seqs = $obj->locations_to_dna_sequences($locations)
$locations is a locations $dna_seqs is a reference to a list where each element is a reference to a list containing 2 items: 0: a location 1: a dna locations is a reference to a list where each element is a location location is a reference to a list where each element is a region_of_dna region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int dna is a string
locations_to_dna_sequences takes as input a list of locations (each in the form of a list of regions). The routine constructs 2-tuples composed of
[the input location,the dna string]
The returned DNA string is formed by concatenating the DNA for each of the regions that make up the location.
$return = $obj->proteins_to_fids($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a fids proteins is a reference to a list where each element is a protein protein is a string fids is a reference to a list where each element is a fid fid is a string
proteins_to_fids takes as input a list of proteins (i.e., a list of md5s) and returns for each a set of protein-encoding fids that have the designated sequence as their translation. That is, for each sequence, the returned fids will be the entire set (within Kbase) that have the sequence as a translation.
$return = $obj->proteins_to_protein_families($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a protein_families proteins is a reference to a list where each element is a protein protein is a string protein_families is a reference to a list where each element is a protein_family protein_family is a string
Protein families contain a set of isofunctional homologs. proteins_to_protein_families can be used to look up is used to get the set of protein_families containing a specified protein. For performance reasons, you can submit a batch of proteins (i.e., a list of proteins), and for each input protein, you get back a set (possibly empty) of protein_families. Specific collections of families (e.g., FIGfams) usually require that a protein be in at most one family. However, we will be integrating protein families from a number of sources, and so a protein can be in multiple families.
$return = $obj->proteins_to_literature($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a pubrefs proteins is a reference to a list where each element is a protein protein is a string pubrefs is a reference to a list where each element is a pubref pubref is a reference to a list containing 3 items: 0: (id) a string 1: (link) a string 2: (title) a string
The routine proteins_to_literature can be used to extract the list of papers we have associated with specific protein sequences. The user should note that in many cases the association of a paper with a protein sequence is not precise. That is, the paper may actually describe a closely-related protein (that may not yet even be in a sequenced genome). Annotators attempt to use best judgement when associating literature and proteins. Publication references include [pubmed ID,URL for the paper, title of the paper]. In some cases, the URL and title are omitted. In theory, we can extract them from PubMed and we will attempt to do so.
$return = $obj->proteins_to_functions($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a fid_function_pairs proteins is a reference to a list where each element is a protein protein is a string fid_function_pairs is a reference to a list where each element is a fid_function_pair fid_function_pair is a reference to a list containing 2 items: 0: a fid 1: a function fid is a string function is a string
The routine proteins_to_functions allows users to access functions associated with specific protein sequences. The input proteins are given as a list of MD5 values (these MD5 values each correspond to a specific protein sequence). For each input MD5 value, a list of [feature-id,function] pairs is constructed and returned. Note that there are many cases in which a single protein sequence corresponds to the translation associated with multiple protein-encoding genes, and each may have distinct functions (an undesirable situation, we grant).
This function allows you to access all of the functions assigned (by all annotation groups represented in Kbase) to each of a set of sequences.
$return = $obj->proteins_to_roles($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a roles proteins is a reference to a list where each element is a protein protein is a string roles is a reference to a list where each element is a role role is a string
The routine proteins_to_roles allows a user to gather the set of functional roles that are associated with specifc protein sequences. A single protein sequence (designated by an MD5 value) may have numerous associated functions, since functions are treated as an attribute of the feature, and multiple features may have precisely the same translation. In our experience, it is not uncommon, even for the best annotation teams, to assign distinct functions (and, hence, functional roles) to identical protein sequences.
For each input MD5 value, this routine gathers the set of features (fids) that share the same sequence, collects the associated functions, expands these into functional roles (for multi-functional proteins), and returns the set of roles that results.
Note that, if the user wishes to see the specific features that have the assigned fiunctional roles, they should use proteins_to_functions instead (it returns the fids associated with each assigned function).
$return = $obj->roles_to_proteins($roles)
$roles is a roles $return is a reference to a hash where the key is a role and the value is a proteins roles is a reference to a list where each element is a role role is a string proteins is a reference to a list where each element is a protein protein is a string
roles_to_proteins can be used to extract the set of proteins (designated by MD5 values) that currently are believed to implement a given role. Note that the proteins may be multifunctional, meaning that they may be implementing other roles, as well.
$return = $obj->roles_to_subsystems($roles)
$roles is a roles $return is a reference to a hash where the key is a role and the value is a subsystems roles is a reference to a list where each element is a role role is a string subsystems is a reference to a list where each element is a subsystem subsystem is a string
roles_to_subsystems can be used to access the set of subsystems that include specific roles. The input is a list of roles (i.e., role descriptions), and a mapping is returned as a hash with key role description and values composed of sets of susbsystem names.
$return = $obj->roles_to_protein_families($roles)
$roles is a roles $return is a reference to a hash where the key is a role and the value is a protein_families roles is a reference to a list where each element is a role role is a string protein_families is a reference to a list where each element is a protein_family protein_family is a string
roles_to_protein_families can be used to locate the protein families containing features that have assigned functions implying that they implement designated roles. Note that for any input role (given as a role description), you may have a set of distinct protein_families returned.
$return = $obj->fids_to_coexpressed_fids($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a scored_fids fids is a reference to a list where each element is a fid fid is a string scored_fids is a reference to a list where each element is a scored_fid scored_fid is a reference to a list containing 2 items: 0: a fid 1: (score) a float
The routine fids_to_coexpressed_fids returns (for each input fid) a list of features that appear to be coexpressed. That is, for an input fid, we determine the set of fids from the same genome that have Pearson Correlation Coefficients (based on normalized expression data) greater than 0.5 or less than -0.5.
$return = $obj->protein_families_to_fids($protein_families)
$protein_families is a protein_families $return is a reference to a hash where the key is a protein_family and the value is a fids protein_families is a reference to a list where each element is a protein_family protein_family is a string fids is a reference to a list where each element is a fid fid is a string
protein_families_to_fids can be used to access the set of fids represented by each of a set of protein_families. We define protein_families as sets of fids (rather than sets of MD5s. This may, or may not, be a mistake.
$return = $obj->protein_families_to_proteins($protein_families)
$protein_families is a protein_families $return is a reference to a hash where the key is a protein_family and the value is a proteins protein_families is a reference to a list where each element is a protein_family protein_family is a string proteins is a reference to a list where each element is a protein protein is a string
protein_families_to_proteins can be used to access the set of proteins (i.e., the set of MD5 values) represented by each of a set of protein_families. We define protein_families as sets of fids (rather than sets of MD5s. This may, or may not, be a mistake.
$return = $obj->protein_families_to_functions($protein_families)
$protein_families is a protein_families $return is a reference to a hash where the key is a protein_family and the value is a function protein_families is a reference to a list where each element is a protein_family protein_family is a string function is a string
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.
$return = $obj->protein_families_to_co_occurring_families($protein_families)
$protein_families is a protein_families $return is a reference to a hash where the key is a protein_family and the value is a fc_protein_families protein_families is a reference to a list where each element is a protein_family protein_family is a string fc_protein_families is a reference to a list where each element is a fc_protein_family fc_protein_family is a reference to a list containing 3 items: 0: a protein_family 1: a score 2: a function score is a float function is a string
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.
$return = $obj->co_occurrence_evidence($pairs_of_fids)
$pairs_of_fids is a pairs_of_fids $return is a reference to a list where each element is a reference to a list containing 2 items: 0: a pair_of_fids 1: an evidence pairs_of_fids is a reference to a list where each element is a pair_of_fids pair_of_fids is a reference to a list containing 2 items: 0: a fid 1: a fid fid is a string evidence is a reference to a list where each element is a pair_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.
$return = $obj->contigs_to_sequences($contigs)
$contigs is a contigs $return is a reference to a hash where the key is a contig and the value is a dna contigs is a reference to a list where each element is a contig contig is a string dna is a string
contigs_to_sequences is used to access the DNA sequence associated with each of a set of input contigs. It takes as input a set of contig IDs (from which the genome can be determined) and produces a mapping from the input IDs to the returned DNA sequence in each case.
$return = $obj->contigs_to_lengths($contigs)
$contigs is a contigs $return is a reference to a hash where the key is a contig and the value is a length contigs is a reference to a list where each element is a contig contig is a string length is an int
In some cases, one wishes to know just the lengths of the contigs, rather than their actual DNA sequence (e.g., suppose that you wished to know if a gene boundary occured within 100 bp of the end of the contig). To avoid requiring a user to access the entire DNA sequence, we offer the ability to retrieve just the contig lengths. Input to the routine is a list of contig IDs. The routine returns a mapping from contig IDs to lengths
$return = $obj->contigs_to_md5s($contigs)
$contigs is a contigs $return is a reference to a hash where the key is a contig and the value is a md5 contigs is a reference to a list where each element is a contig contig is a string md5 is a string
contigs_to_md5s can be used to acquire MD5 values for each of a list of contigs. The quickest way to determine whether two contigs are identical is to compare their associated MD5 values, eliminating the need to retrieve the sequence of each and compare them.
The routine takes as input a list of contig IDs. The output is a mapping from contig ID to MD5 value.
$return = $obj->md5s_to_genomes($md5s)
$md5s is a md5s $return is a reference to a hash where the key is a md5 and the value is a genomes md5s is a reference to a list where each element is a md5 md5 is a string genomes is a reference to a list where each element is a genome genome is a string
md5s to genomes is used to get the genomes associated with each of a list of input md5 values.
The routine takes as input a list of MD5 values. It constructs a mapping from each input
MD5 value to a list of genomes that share the same MD5 value.
The MD5 value for a genome is independent of the names of contigs and the case of the DNA sequence
data.
$return = $obj->genomes_to_md5s($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a md5 genomes is a reference to a list where each element is a genome genome is a string md5 is a string
The routine genomes_to_md5s can be used to look up the MD5 value associated with each of a set of genomes. The MD5 values are computed when the genome is loaded, so this routine just retrieves the precomputed values.
Note that the MD5 value of a genome is independent of the contig names and case of the DNA sequences that make up the genome.
$return = $obj->genomes_to_contigs($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a contigs genomes is a reference to a list where each element is a genome genome is a string contigs is a reference to a list where each element is a contig contig is a string
The routine genomes_to_contigs can be used to retrieve the IDs of the contigs associated with each of a list of input genomes. The routine constructs a mapping from genome ID to the list of contigs included in the genome.
$return = $obj->genomes_to_fids($genomes, $types_of_fids)
$genomes is a genomes $types_of_fids is a types_of_fids $return is a reference to a hash where the key is a genome and the value is a fids genomes is a reference to a list where each element is a genome genome is a string types_of_fids is a reference to a list where each element is a type_of_fid type_of_fid is a string fids is a reference to a list where each element is a fid fid is a string
genomes_to_fids bis used to get the fids included in specific genomes. It is often the case that you want just one or two types of fids -- hence, the types_of_fids argument.
$return = $obj->genomes_to_taxonomies($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a taxonomic_groups genomes is a reference to a list where each element is a genome genome is a string taxonomic_groups is a reference to a list where each element is a taxonomic_group taxonomic_group is a string
The routine genomes_to_taxonomies can be used to retrieve taxonomic information for each of a list of input genomes. For each genome in the input list of genomes, a list of taxonomic groups is returned. KBase will use the groups maintained by NCBI. For an NCBI taxonomic string like
cellular organisms;
Bacteria;
Proteobacteria;
Gammaproteobacteria;
Enterobacteriales;
Enterobacteriaceae;
Escherichia;
Escherichia coli
associated with the strain 'Escherichia coli 1412', this routine would return a list of these taxonomic groups:
['Bacteria',
'Proteobacteria',
'Gammaproteobacteria',
'Enterobacteriales',
'Enterobacteriaceae',
'Escherichia',
'Escherichia coli',
'Escherichia coli 1412'
]
That is, the initial "cellular organisms" has been deleted, and the strain ID has been added as the last "grouping".
The output is a mapping from genome IDs to lists of the form shown above.
$return = $obj->genomes_to_subsystems($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a variant_subsystem_pairs genomes is a reference to a list where each element is a genome genome is a string variant_subsystem_pairs is a reference to a list where each element is a variant_of_subsystem variant_of_subsystem is a reference to a list containing 2 items: 0: a subsystem 1: a variant subsystem is a string variant is a string
A user can invoke genomes_to_subsystems to rerieve the names of the subsystems relevant to each genome. The input is a list of genomes. The output is a mapping from genome to a list of 2-tuples, where each 2-tuple give a variant code and a subsystem name. Variant codes of -1 (or *-1) amount to assertions that the genome contains no active variant. A variant code of 0 means "work in progress", and presence or absence of the subsystem in the genome should be undetermined.
$return = $obj->subsystems_to_genomes($subsystems)
$subsystems is a subsystems $return is a reference to a hash where the key is a subsystem and the value is a reference to a list where each element is a reference to a list containing 2 items: 0: a variant 1: a genome subsystems is a reference to a list where each element is a subsystem subsystem is a string variant is a string genome is a string
The routine subsystems_to_genomes is used to determine which genomes are in specified subsystems. The input is the list of subsystem names of interest. The output is a map from the subsystem names to lists of 2-tuples, where each 2-tuple is a [variant-code,genome ID] pair.
$return = $obj->subsystems_to_fids($subsystems, $genomes)
$subsystems is a subsystems $genomes is a genomes $return is a reference to a hash where the key is a subsystem and the value is a reference to a hash where the key is a genome and the value is a reference to a list where each element is a reference to a list containing 2 items: 0: a variant 1: a fids subsystems is a reference to a list where each element is a subsystem subsystem is a string genomes is a reference to a list where each element is a genome genome is a string variant is a string fids is a reference to a list where each element is a fid fid is a string
The routine subsystems_to_fids allows the user to map subsystem names into the fids that occur in genomes in the subsystems. Specifically, the input is a list of subsystem names. What is returned is a mapping from subsystem names to a "genome-mapping". The genome-mapping takes genome IDs to 2-tuples that capture the variant code of the genome and the fids from the genome that are included in the subsystem.
$return = $obj->subsystems_to_roles($subsystems, $aux)
$subsystems is a subsystems $aux is an aux $return is a reference to a hash where the key is a subsystem and the value is a roles subsystems is a reference to a list where each element is a subsystem subsystem is a string aux is an int roles is a reference to a list where each element is a role role is a string
The routine subsystem_to_roles is used to determine the role descriptions that occur in a subsystem. The input is a list of subsystem names. A map is returned connecting subsystem names to lists of roles. 'aux' is a boolean variable. If it is 0, auxiliary roles are not returned. If it is 1, they are returned.
$return = $obj->subsystems_to_spreadsheets($subsystems, $genomes)
$subsystems is a subsystems $genomes is a genomes $return is a reference to a hash where the key is a subsystem and the value is a reference to a hash where the key is a genome and the value is a row subsystems is a reference to a list where each element is a subsystem subsystem is a string genomes is a reference to a list where each element is a genome genome is a string row is a reference to a list containing 2 items: 0: a variant 1: a reference to a hash where the key is a role and the value is a fids variant is a string role is a string fids is a reference to a list where each element is a fid fid is a string
The subsystem_to_spreadsheet routine allows a user to extract the subsystem spreadsheets for a specified set of subsystem names. In the returned output, each subsystem is mapped to a hash that takes as input a genome ID and maps it to the "row" for the genome in the subsystem. The "row" is itself a 2-tuple composed of the variant code, and a mapping from role descriptions to lists of fids. We suggest writing a simple test script to get, say, the subsystem named 'Histidine Degradation', extracting the spreadsheet, and then using something like Dumper to make sure that it all makes sense.
$return = $obj->all_roles_used_in_models()
$return is a roles roles is a reference to a list where each element is a role role is a string
The all_roles_used_in_models allows a user to access the set of roles that are included in current models. This is important. There are far fewer roles used in models than overall. Hence, the returned set represents the minimal set we need to clean up in order to properly support modeling.
$return = $obj->complexes_to_complex_data($complexes)
$complexes is a complexes $return is a reference to a hash where the key is a complex and the value is a complex_data complexes is a reference to a list where each element is a complex complex is a string complex_data is a reference to a hash where the following keys are defined: complex_name has a value which is a name complex_roles has a value which is a roles_with_flags complex_reactions has a value which is a reactions name is a string roles_with_flags is a reference to a list where each element is a role_with_flag role_with_flag is a reference to a list containing 2 items: 0: a role 1: an optional role is a string optional is a string reactions is a reference to a list where each element is a reaction reaction is a string
$return = $obj->genomes_to_genome_data($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a genome_data genomes is a reference to a list where each element is a genome genome is a string genome_data is a reference to a hash where the following keys are defined: complete has a value which is an int contigs has a value which is an int dna_size has a value which is an int gc_content has a value which is a float genetic_code has a value which is an int pegs has a value which is an int rnas has a value which is an int scientific_name has a value which is a string taxonomy has a value which is a string genome_md5 has a value which is a string
$return = $obj->fids_to_regulon_data($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a regulons_data fids is a reference to a list where each element is a fid fid is a string regulons_data is a reference to a list where each element is a regulon_data regulon_data is a reference to a hash where the following keys are defined: regulon_id has a value which is a regulon regulon_set has a value which is a fids tfs has a value which is a fids regulon is a string
$return = $obj->regulons_to_fids($regulons)
$regulons is a regulons $return is a reference to a hash where the key is a regulon and the value is a fids regulons is a reference to a list where each element is a regulon regulon is a string fids is a reference to a list where each element is a fid fid is a string
$return = $obj->fids_to_feature_data($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a feature_data fids is a reference to a list where each element is a fid fid is a string feature_data is a reference to a hash where the following keys are defined: feature_id has a value which is a fid genome_name has a value which is a string feature_function has a value which is a string feature_length has a value which is an int feature_publications has a value which is a pubrefs feature_location has a value which is a location pubrefs is a reference to a list where each element is a pubref pubref is a reference to a list containing 3 items: 0: (id) a string 1: (link) a string 2: (title) a string location is a reference to a list where each element is a region_of_dna region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int
$return = $obj->equiv_sequence_assertions($proteins)
$proteins is a proteins $return is a reference to a hash where the key is a protein and the value is a function_assertions proteins is a reference to a list where each element is a protein protein is a string function_assertions is a reference to a list where each element is a function_assertion function_assertion is a reference to a list containing 3 items: 0: an id 1: a function 2: a source id is a string function is a string source is a string
Different groups have made assertions of function for numerous protein sequences. The equiv_sequence_assertions allows the user to gather function assertions from all of the sources. Each assertion includes a field indicating whether the person making the assertion viewed themself as an "expert". The routine gathers assertions for all proteins having identical protein sequence.
$return = $obj->fids_to_atomic_regulons($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is an atomic_regulon_size_pairs fids is a reference to a list where each element is a fid fid is a string atomic_regulon_size_pairs is a reference to a list where each element is an atomic_regulon_size_pair atomic_regulon_size_pair is a reference to a list containing 2 items: 0: an atomic_regulon 1: an atomic_regulon_size atomic_regulon is a string atomic_regulon_size is an int
The fids_to_atomic_regulons allows one to map fids into regulons that contain the fids. Normally a fid will be in at most one regulon, but we support multiple regulons.
$return = $obj->atomic_regulons_to_fids($atomic_regulons)
$atomic_regulons is an atomic_regulons $return is a reference to a hash where the key is an atomic_regulon and the value is a fids atomic_regulons is a reference to a list where each element is an atomic_regulon atomic_regulon is a string fids is a reference to a list where each element is a fid fid is a string
The atomic_regulons_to_fids routine allows the user to access the set of fids that make up a regulon. Regulons may arise from several sources; hence, fids can be in multiple regulons.
$return = $obj->fids_to_protein_sequences($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a protein_sequence fids is a reference to a list where each element is a fid fid is a string protein_sequence is a string
fids_to_protein_sequences allows the user to look up the amino acid sequences corresponding to each of a set of fids. You can also get the sequence from proteins (i.e., md5 values). This routine saves you having to look up the md5 sequence and then accessing the protein string in a separate call.
$return = $obj->fids_to_proteins($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a md5 fids is a reference to a list where each element is a fid fid is a string md5 is a string
$return = $obj->fids_to_dna_sequences($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a dna_sequence fids is a reference to a list where each element is a fid fid is a string dna_sequence is a string
fids_to_dna_sequences allows the user to look up the DNA sequences corresponding to each of a set of fids.
$return = $obj->roles_to_fids($roles, $genomes)
$roles is a roles $genomes is a genomes $return is a reference to a hash where the key is a role and the value is a fid roles is a reference to a list where each element is a role role is a string genomes is a reference to a list where each element is a genome genome is a string fid is a string
A "function" is a set of "roles" (often called "functional roles");
F1 / F2 (where F1 and F2 are roles) is a function that implements
two functional roles in different domains of the protein.
F1 @ F2 implements multiple roles through broad specificity
F1; F2 is thought to implement F1 or f2 (uncertainty)
You often wish to find the fids in one or more genomes that
implement specific functional roles. To do this, you can use
roles_to_fids.
$return = $obj->reactions_to_complexes($reactions)
$reactions is a reactions $return is a reference to a hash where the key is a reaction and the value is a complexes_with_flags reactions is a reference to a list where each element is a reaction reaction is a string complexes_with_flags is a reference to a list where each element is a complex_with_flag complex_with_flag is a reference to a list containing 2 items: 0: a complex 1: an optional complex is a string optional is a string
Reactions are thought of as being either spontaneous or implemented by one or more Complexes. Complexes connect to Roles. Hence, the connection of fids or roles to reactions goes through Complexes.
$return = $obj->aliases_to_fids($aliases)
$aliases is an aliases $return is a reference to a hash where the key is an alias and the value is a fid aliases is a reference to a list where each element is an alias alias is a string fid is a string
$return = $obj->external_ids_to_fids($external_ids, $prefix_match)
$external_ids is an external_ids $prefix_match is an int $return is a reference to a hash where the key is an external_id and the value is a fid external_ids is a reference to a list where each element is an external_id external_id is a string fid is a string
$return = $obj->reaction_strings($reactions, $name_parameter)
$reactions is a reactions $name_parameter is a name_parameter $return is a reference to a hash where the key is a reaction and the value is a string reactions is a reference to a list where each element is a reaction reaction is a string name_parameter is a string
Reaction_strings are text strings that represent (albeit crudely) the details of Reactions.
$return = $obj->roles_to_complexes($roles)
$roles is a roles $return is a reference to a hash where the key is a role and the value is a complexes roles is a reference to a list where each element is a role role is a string complexes is a reference to a list where each element is a complex complex is a string
roles_to_complexes allows a user to connect Roles to Complexes, from there, the connection exists to Reactions (although in the actual ER-model model, the connection from Complex to Reaction goes through ReactionComplex). Since Roles also connect to fids, the connection between fids and Reactions is induced.
The "name_parameter" can be 0, 1 or 'only'. If 1, then the compound name will be included with the ID in the output. If only, the compound name will be included instead of the ID. If 0, only the ID will be included. The default is 0.
$return = $obj->complexes_to_roles($complexes)
$complexes is a complexes $return is a reference to a hash where the key is a complexes and the value is a roles complexes is a reference to a list where each element is a complex complex is a string roles is a reference to a list where each element is a role role is a string
$return = $obj->fids_to_subsystem_data($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a ss_var_role_tuples fids is a reference to a list where each element is a fid fid is a string ss_var_role_tuples is a reference to a list where each element is a ss_var_role_tuple ss_var_role_tuple is a reference to a list containing 3 items: 0: a subsystem 1: a variant 2: a role subsystem is a string variant is a string role is a string
$return = $obj->representative($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a genome genomes is a reference to a list where each element is a genome genome is a string
$return = $obj->otu_members($genomes)
$genomes is a genomes $return is a reference to a hash where the key is a genome and the value is a reference to a hash where the key is a genome and the value is a genome_name genomes is a reference to a list where each element is a genome genome is a string genome_name is a string
$return = $obj->otus_to_representatives($otus)
$otus is a reference to a list where each element is an int $return is a reference to a hash where the key is an int and the value is a genome genome is a string
$return = $obj->fids_to_genomes($fids)
$fids is a fids $return is a reference to a hash where the key is a fid and the value is a genome fids is a reference to a list where each element is a fid fid is a string genome is a string
$return = $obj->text_search($input, $start, $count, $entities)
$input is a string $start is an int $count is an int $entities is a reference to a list where each element is a string $return is a reference to a hash where the key is an entity_name and the value is a reference to a list where each element is a search_hit entity_name is a string search_hit is a reference to a list containing 2 items: 0: a weight 1: a reference to a hash where the key is a field_name and the value is a string weight is an int field_name is a string
text_search performs a search against a full-text index maintained for the CDMI. The parameter "input" is the text string to be searched for. The parameter "entities" defines the entities to be searched. If the list is empty, all indexed entities will be searched. The "start" and "count" parameters limit the results to "count" hits starting at "start".
$return = $obj->corresponds($fids, $genome)
$fids is a fids $genome is a genome $return is a reference to a hash where the key is a fid and the value is a correspondence fids is a reference to a list where each element is a fid fid is a string genome is a string correspondence is a reference to a hash where the following keys are defined: to has a value which is a fid iden has a value which is a float ncontext has a value which is an int b1 has a value which is an int e1 has a value which is an int ln1 has a value which is an int b2 has a value which is an int e2 has a value which is an int ln2 has a value which is an int score has a value which is an int
$return = $obj->corresponds_from_sequences($g1_sequences, $g1_locations, $g2_sequences, $g2_locations)
$g1_sequences is a reference to a list where each element is a reference to a list containing 2 items: 0: a fid 1: a protein_sequence $g1_locations is a reference to a list where each element is a reference to a list containing 2 items: 0: a fid 1: a location $g2_sequences is a reference to a list where each element is a reference to a list containing 2 items: 0: a fid 1: a protein_sequence $g2_locations is a reference to a list where each element is a reference to a list containing 2 items: 0: a fid 1: a location $return is a reference to a hash where the key is a fid and the value is a correspondence fid is a string protein_sequence is a string location is a reference to a list where each element is a region_of_dna region_of_dna is a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length contig is a string begin is an int strand is a string length is an int correspondence is a reference to a hash where the following keys are defined: to has a value which is a fid iden has a value which is a float ncontext has a value which is an int b1 has a value which is an int e1 has a value which is an int ln1 has a value which is an int b2 has a value which is an int e2 has a value which is an int ln2 has a value which is an int score has a value which is an int
$return = $obj->close_genomes($seq_set, $n)
$seq_set is a seq_set $n is an int $return is a reference to a list where each element is a reference to a list containing 2 items: 0: a genome 1: (ident) a float seq_set is a reference to a list where each element is a seq_triple seq_triple is a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence id is a string comment is a string sequence is a string genome is a string
$return_1, $return_2 = $obj->representative_sequences($seq_set, $rep_seq_parms)
$seq_set is a seq_set $rep_seq_parms is a rep_seq_parms $return_1 is an id_set $return_2 is a reference to a list where each element is an id_set seq_set is a reference to a list where each element is a seq_triple seq_triple is a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence id is a string comment is a string sequence is a string rep_seq_parms is a reference to a hash where the following keys are defined: existing_reps has a value which is a seq_set order has a value which is a string alg has a value which is an int type_sim has a value which is a string cutoff has a value which is a float id_set is a reference to a list where each element is an id
we return two arguments. The first is the list of representative triples, and the second is the list of sets (the first entry always being the representative sequence)
$return = $obj->align_sequences($seq_set, $align_seq_parms)
$seq_set is a seq_set $align_seq_parms is an align_seq_parms $return is an alignment seq_set is a reference to a list where each element is a seq_triple seq_triple is a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence id is a string comment is a string sequence is a string align_seq_parms is a reference to a hash where the following keys are defined: muscle_parms has a value which is a muscle_parms_t mafft_parms has a value which is a mafft_parms_t tool has a value which is a string align_ends_with_clustal has a value which is an int muscle_parms_t is a reference to a hash where the following keys are defined: anchors has a value which is an int brenner has a value which is an int cluster has a value which is an int dimer has a value which is an int diags has a value which is an int diags1 has a value which is an int diags2 has a value which is an int le has a value which is an int noanchors has a value which is an int sp has a value which is an int spn has a value which is an int stable has a value which is an int sv has a value which is an int anchorspacing has a value which is a string center has a value which is a string cluster1 has a value which is a string cluster2 has a value which is a string diagbreak has a value which is a string diaglength has a value which is a string diagmargin has a value which is a string distance1 has a value which is a string distance2 has a value which is a string gapopen has a value which is a string log has a value which is a string loga has a value which is a string matrix has a value which is a string maxhours has a value which is a string maxiters has a value which is a string maxmb has a value which is a string maxtrees has a value which is a string minbestcolscore has a value which is a string minsmoothscore has a value which is a string objscore has a value which is a string refinewindow has a value which is a string root1 has a value which is a string root2 has a value which is a string scorefile has a value which is a string seqtype has a value which is a string smoothscorecell has a value which is a string smoothwindow has a value which is a string spscore has a value which is a string SUEFF has a value which is a string usetree has a value which is a string weight1 has a value which is a string weight2 has a value which is a string mafft_parms_t is a reference to a hash where the following keys are defined: sixmerpair has a value which is an int amino has a value which is an int anysymbol has a value which is an int auto has a value which is an int clustalout has a value which is an int dpparttree has a value which is an int fastapair has a value which is an int fastaparttree has a value which is an int fft has a value which is an int fmodel has a value which is an int genafpair has a value which is an int globalpair has a value which is an int inputorder has a value which is an int localpair has a value which is an int memsave has a value which is an int nofft has a value which is an int noscore has a value which is an int parttree has a value which is an int reorder has a value which is an int treeout has a value which is an int alg has a value which is a string aamatrix has a value which is a string bl has a value which is a string ep has a value which is a string groupsize has a value which is a string jtt has a value which is a string lap has a value which is a string lep has a value which is a string lepx has a value which is a string LOP has a value which is a string LEXP has a value which is a string maxiterate has a value which is a string op has a value which is a string partsize has a value which is a string retree has a value which is a string thread has a value which is a string tm has a value which is a string weighti has a value which is a string alignment is a seq_set
$return = $obj->build_tree($alignment, $build_tree_parms)
$alignment is an alignment $build_tree_parms is a build_tree_parms $return is a newick_tree alignment is a seq_set seq_set is a reference to a list where each element is a seq_triple seq_triple is a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence id is a string comment is a string sequence is a string build_tree_parms is a reference to a hash where the following keys are defined: bootstrap has a value which is a string model has a value which is a string nclasses has a value which is a string nproc has a value which is a string rate has a value which is a string search has a value which is a string tool has a value which is a string tool_params has a value which is a string newick_tree is a string
$return = $obj->alignment_by_id($aln_id)
$aln_id is an aln_id $return is an alignment aln_id is a string alignment is a seq_set seq_set is a reference to a list where each element is a seq_triple seq_triple is a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence id is a string comment is a string sequence is a string
$return = $obj->tree_by_id($tree_id)
$tree_id is a tree_id $return is a newick_tree tree_id is a string newick_tree is a string
$return = $obj->all_entities()
$return is an entity_names entity_names is a reference to a list where each element is an entity_name entity_name is a string
Returns a list of all entities in the database.
$return = $obj->all_relationships()
$return is a relationship_names relationship_names is a reference to a list where each element is a relationship_name relationship_name is a string
Returns a list of all relationships in the database.
$return = $obj->get_entity($entity_names)
$entity_names is an entity_names $return is a reference to a hash where the key is a string and the value is an entity_info entity_names is a reference to a list where each element is an entity_name entity_name is a string entity_info is a reference to a hash where the following keys are defined: name has a value which is a string relationships has a value which is a reference to a list where each element is a reference to a list containing 2 items: 0: (rel_name) a string 1: (entity_name) a string fields has a value which is a reference to a hash where the key is a field_name and the value is a field_info field_name is a string field_info is a reference to a hash where the following keys are defined: name has a value which is a string notes has a value which is a string type has a value which is a string
Returns information about a set of entities in the database. Invalid entity names are ignored.
$return = $obj->get_relationship($relationship_names)
$relationship_names is a relationship_names $return is a reference to a hash where the key is a string and the value is a relationship_info relationship_names is a reference to a list where each element is a relationship_name relationship_name is a string relationship_info is a reference to a hash where the following keys are defined: name has a value which is a string from_entity has a value which is a string to_entity has a value which is a string real_table has a value which is a boolean converse has a value which is a string fields has a value which is a reference to a hash where the key is a field_name and the value is a field_info boolean is an int field_name is a string field_info is a reference to a hash where the following keys are defined: name has a value which is a string notes has a value which is a string type has a value which is a string
Returns information about a set of relationships in the database. Invalid relationship names are ignored.
$return = $obj->version()
$return is a string
Return the module version. This is a Semantic Versioning number.
a string
an int
a string
A fid is a "feature id". A feature represents an ordered list of regions from the contigs of a genome. Features all have types. This allows you to speak of not only protein-encoding genes (PEGs) and RNAs, but also binding sites, large regions, etc. The location of a fid is defined as a list of "location of a contiguous DNA string" pieces (see the description of the type "location")
a string
A protein_family is thought of as a set of isofunctional, homologous protein sequences. This is not exactly what other groups have meant by "protein families". There is no hierarchy of super-family, family, sub-family. We plan on loading different collections of protein families, but in many cases there will need to be a transformation into the concept used by Kbase.
a string
The concept of "role" or "functional role" is basically an atomic functional unit. The "function of a protein" is made up of one or more roles. That is, a bifunctional protein with an assigned function of
5-Enolpyruvylshikimate-3-phosphate synthase (EC <IP_ADDRESS>) / Cytidylate kinase (EC <IP_ADDRESS>)
would implement two distinct roles (the "function1 / function2" notation is intended to assert that the initial part of the protein implements function1, and the terminal part of the protein implements function2). It is worth noting that a protein often implements multiple roles due to broad specificity. In this case, we suggest describing the protein function as
function1 @ function2
That is the ' / ' separator is used to represent multiple roles implemented by distinct domains of the protein, while ' @ ' is used to represent multiple roles implemented by distinct domains.
a string
A substem is composed of two components: a set of roles that are gathered to be annotated simultaneously and a spreadsheet depicting the proteins within each genome that implement the roles. The set of roles may correspond to a pathway, a complex, an inventory (say, "transporters") or whatever other principle an annotator used to formulate the subsystem.
The subsystem spreadsheet is a list of "rows", each representing the subsytem in a specific genome. Each row includes a variant code (indicating what version of the molecular machine exists in the genome) and cells. Each cell is a 2-tuple:
[role,protein-encoding genes that implement the role in the genome]
Annotators construct subsystems, and in the process impose a controlled vocabulary for roles and functions.
a string
a string
a reference to a list containing 2 items: 0: a subsystem 1: a variant
a reference to a list where each element is a variant_of_subsystem
a string
a reference to a list where each element is a type_of_fid
an int
an int
In encodings of locations, we often specify strands. We specify the strand as '+' or '-'
a string
a string
A region of DNA is maintained as a tuple of four components:
the contig
the beginning position (from 1)
the strand
the length
We often speak of "a region". By "location", we mean a sequence
of regions from the same genome (perhaps from distinct contigs).
a reference to a list containing 4 items: 0: a contig 1: a begin 2: a strand 3: a length
a "location" refers to a sequence of regions
a reference to a list where each element is a region_of_dna
a reference to a list where each element is a location
we often need to represent regions or locations as strings. We would use something like
contigA_200+100,contigA_402+188
to represent a location composed of two regions
a string
a reference to a list where each element is a region_of_dna_string
a string
a string
a string
a string
a string
a string
a string
The KBase stores annotations relating to features. Each annotation is a 3-tuple:
the text of the annotation (often a record of assertion of function)
the annotator attaching the annotation to the feature
the time (in seconds from the epoch) at which the annotation was attached
a reference to a list containing 3 items: 0: a comment 1: an annotator 2: an annotation_time
The KBase will include a growing body of literature supporting protein functions, asserted phenotypes, etc. References are encoded as 3-tuples:
an id (often a PubMed ID)
a URL to the paper
a title of the paper
The URL and title are often missing (but, can usually be inferred from the pubmed ID).
a reference to a list containing 3 items: 0: (id) a string 1: (link) a string 2: (title) a string
a reference to a list containing 2 items: 0: a fid 1: (score) a float
a reference to a list where each element is an annotation
a reference to a list where each element is a pubref
a reference to a list where each element is a role
a string
a reference to a list containing 2 items: 0: a role 1: an optional
a reference to a list where each element is a role_with_flag
a reference to a list where each element is a scored_fid
a reference to a list where each element is a protein
a reference to a list where each element is a function
a reference to a list where each element is a taxonomic_group
a reference to a list where each element is a subsystem
a reference to a list where each element is a contig
a reference to a list where each element is a md5
a reference to a list where each element is a genome
a reference to a list containing 2 items: 0: a fid 1: a fid
a reference to a list where each element is a pair_of_fids
a reference to a list where each element is a protein_family
a float
a reference to a list where each element is a pair_of_fids
a reference to a list where each element is a fid
a reference to a list containing 2 items: 0: a variant 1: a reference to a hash where the key is a role and the value is a fids
a reference to a list containing 2 items: 0: a fid 1: a function
a reference to a list where each element is a fid_function_pair
A functionally coupled protein family identifies a family, a score, and a function (of the related family)
a reference to a list containing 3 items: 0: a protein_family 1: a score 2: a function
a reference to a list where each element is a fc_protein_family
We now have a number of types and functions relating to ObservationalUnits (ous), alleles and traits. We think of a reference genome and a set of ous that have measured differences (SNPs) when compared to the reference genome. Each allele is associated with a position on a contig of the reference genome. Prior analysis has associated traits with the alleles that impact them. We are interested in supporting operations that locate genes in the region of an allele (i.e., genes of the reference genome that are in a region containining an allele). Similarly, we wish to locate the alleles that impact a trait, map the alleles to regions, loacte the possibly impacted genes, relate these to subsystems, etc.
a string
a reference to a list where each element is an allele
a string
a reference to a list where each element is a trait
a string
a reference to a list where each element is an ou
a reference to a list containing 2 items: 0: a contig 1: (position) an int
a string
a float
an int
a reference to a list where each element is a string
a string
a reference to a list containing 2 items: 0: a complex 1: an optional
a reference to a list where each element is a complex_with_flag
a reference to a list where each element is a complex
a string
a string
a reference to a list where each element is a reaction
Reactions do not connect directly to roles. Rather, the conceptual model is that one or more roles together form a complex. A complex implements one or more reactions. The actual data relating to a complex is spread over two entities: Complex and ReactionComplex. It is convenient to be able to offer access to the complex name, the reactions it implements, and the roles that make it up in a single invocation.
a reference to a hash where the following keys are defined: complex_name has a value which is a name complex_roles has a value which is a roles_with_flags complex_reactions has a value which is a reactions
a reference to a hash where the following keys are defined: complete has a value which is an int contigs has a value which is an int dna_size has a value which is an int gc_content has a value which is a float genetic_code has a value which is an int pegs has a value which is an int rnas has a value which is an int scientific_name has a value which is a string taxonomy has a value which is a string genome_md5 has a value which is a string
a string
a reference to a list where each element is a regulon
a reference to a hash where the following keys are defined: regulon_id has a value which is a regulon regulon_set has a value which is a fids tfs has a value which is a fids
a reference to a list where each element is a regulon_data
a reference to a hash where the following keys are defined: feature_id has a value which is a fid genome_name has a value which is a string feature_function has a value which is a string feature_length has a value which is an int feature_publications has a value which is a pubrefs feature_location has a value which is a location
a string
a string
a string
a reference to a list containing 3 items: 0: an id 1: a function 2: a source
a reference to a list where each element is a function_assertion
a string
an int
a reference to a list containing 2 items: 0: an atomic_regulon 1: an atomic_regulon_size
a reference to a list where each element is an atomic_regulon_size_pair
a reference to a list where each element is an atomic_regulon
a string
a string
a string
a reference to a list where each element is an alias
a string
a reference to a list where each element is an external_id
a string
a reference to a list containing 3 items: 0: a subsystem 1: a variant 2: a role
a reference to a list where each element is a ss_var_role_tuple
a string
a string
an int
a string
a reference to a list containing 2 items: 0: a weight 1: a reference to a hash where the key is a field_name and the value is a string
A correspondence is generated as a mapping of fids to fids. The mapping attempts to map a fid to another that performs the same function. The correspondence describes the regions that are similar, the strength of the similarity, the number of genes in the chromosomal context that appear to "correspond" and a score from 0 to 1 that loosely corresponds to confidence in the correspondence.
a reference to a hash where the following keys are defined: to has a value which is a fid iden has a value which is a float ncontext has a value which is an int b1 has a value which is an int e1 has a value which is an int ln1 has a value which is an int b2 has a value which is an int e2 has a value which is an int ln2 has a value which is an int score has a value which is an int
A close_genomes is used to get a set of relatively close genomes (for each input genome, a set of close genomes is calculated, but the result should be viewed as quite approximate. It is quite slow, using similarities for a universal protein as the basis for the assessments. It produces estimates of degree of similarity for the universal proteins it samples.
Up to n genomes will be returned for each input genome.
a string
a reference to a list containing 3 items: 0: an id 1: a comment 2: a sequence
a reference to a list where each element is a seq_triple
a reference to a list where each element is an id
a seq_set
fractions or bits
a reference to a hash where the following keys are defined: existing_reps has a value which is a seq_set order has a value which is a string alg has a value which is an int type_sim has a value which is a string cutoff has a value which is a float
a reference to a hash where the following keys are defined: anchors has a value which is an int brenner has a value which is an int cluster has a value which is an int dimer has a value which is an int diags has a value which is an int diags1 has a value which is an int diags2 has a value which is an int le has a value which is an int noanchors has a value which is an int sp has a value which is an int spn has a value which is an int stable has a value which is an int sv has a value which is an int anchorspacing has a value which is a string center has a value which is a string cluster1 has a value which is a string cluster2 has a value which is a string diagbreak has a value which is a string diaglength has a value which is a string diagmargin has a value which is a string distance1 has a value which is a string distance2 has a value which is a string gapopen has a value which is a string log has a value which is a string loga has a value which is a string matrix has a value which is a string maxhours has a value which is a string maxiters has a value which is a string maxmb has a value which is a string maxtrees has a value which is a string minbestcolscore has a value which is a string minsmoothscore has a value which is a string objscore has a value which is a string refinewindow has a value which is a string root1 has a value which is a string root2 has a value which is a string scorefile has a value which is a string seqtype has a value which is a string smoothscorecell has a value which is a string smoothwindow has a value which is a string spscore has a value which is a string SUEFF has a value which is a string usetree has a value which is a string weight1 has a value which is a string weight2 has a value which is a string
linsi | einsi | ginsi | nwnsi | nwns | fftnsi | fftns (D)
a reference to a hash where the following keys are defined: sixmerpair has a value which is an int amino has a value which is an int anysymbol has a value which is an int auto has a value which is an int clustalout has a value which is an int dpparttree has a value which is an int fastapair has a value which is an int fastaparttree has a value which is an int fft has a value which is an int fmodel has a value which is an int genafpair has a value which is an int globalpair has a value which is an int inputorder has a value which is an int localpair has a value which is an int memsave has a value which is an int nofft has a value which is an int noscore has a value which is an int parttree has a value which is an int reorder has a value which is an int treeout has a value which is an int alg has a value which is a string aamatrix has a value which is a string bl has a value which is a string ep has a value which is a string groupsize has a value which is a string jtt has a value which is a string lap has a value which is a string lep has a value which is a string lepx has a value which is a string LOP has a value which is a string LEXP has a value which is a string maxiterate has a value which is a string op has a value which is a string partsize has a value which is a string retree has a value which is a string thread has a value which is a string tm has a value which is a string weighti has a value which is a string
a reference to a hash where the following keys are defined: muscle_parms has a value which is a muscle_parms_t mafft_parms has a value which is a mafft_parms_t tool has a value which is a string align_ends_with_clustal has a value which is an int
a string
a reference to a hash where the following keys are defined: bootstrap has a value which is a string model has a value which is a string nclasses has a value which is a string nproc has a value which is a string rate has a value which is a string search has a value which is a string tool has a value which is a string tool_params has a value which is a string
a string
a string
a string
a reference to a list where each element is an entity_name
a string
a reference to a list where each element is a relationship_name
a string
an int
Information about a field in the database. Includes the name of the field, any associated formatted notes, and the type.
a reference to a hash where the following keys are defined: name has a value which is a string notes has a value which is a string type has a value which is a string
Information about an entity in the database, including the entity name and its relationships and fields.
a reference to a hash where the following keys are defined: name has a value which is a string relationships has a value which is a reference to a list where each element is a reference to a list containing 2 items: 0: (rel_name) a string 1: (entity_name) a stringfields has a value which is a reference to a hash where the key is a field_name and the value is a field_info
Information about a relationship in the database, including the entities it relates, its name and converse name, and its fields. The real_table boolean designates that the relationship is a real table in the database rather than the converse relationship to that table.
a reference to a hash where the following keys are defined: name has a value which is a string from_entity has a value which is a string to_entity has a value which is a string real_table has a value which is a boolean converse has a value which is a string fields has a value which is a reference to a hash where the key is a field_name and the value is a field_info


You can use SUICA at stations in Tokyo, Kyoto, Osaka, Nagoya and many other places in Japan. So you can go almost anywhere in Japan.
*You can use SUICA in each area but you cannot use it for SHINKANSEN.
You can use SUICA in many stores, cafes and restaurants.
You don't need calculate Japanese yen, every time you pay money.
Top-up: 2,000JPY
Daily : 2,000JPY
*Including postage costs
Top-up: 10,000JPY
Daily : 2,000JPY
*Including postage costs
Top-up: 20,000JPY
Daily : 2,000JPY
*Including postage costs
Please note that this card is not 1day, 5day or 10day passport, so you can use this card within topped-up amount.
In many cases we assume that you can go anywhere in each area like Tokyo, Kyoto etc... within 2,000JPY in one day.


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| js/ | 74.26% | 75/101 | 51.85% | 28/54 | 88.89% | 8/9 | 74.26% | 75/101 | |
| js/common/ | 43.98% | 303/689 | 30.43% | 143/470 | 50.49% | 52/103 | 43.9% | 302/688 | |
| js/ejs/ | 19.75% | 32/162 | 7.92% | 16/202 | 11.11% | 7/63 | 19.73% | 29/147 | |
| js/ejs/v2/ | 17.1% | 198/1158 | 5.6% | 60/1072 | 11.6% | 34/293 | 17.13% | 198/1156 | |
| js/libs/ | 17.3% | 160/925 | 4.84% | 40/827 | 7.45% | 24/322 | 32.8% | 61/186 | |
| js/mui/ | 17.1% | 490/2866 | 3.22% | 62/1926 | 18.27% | 74/405 | 17.18% | 490/2852 | |
| js/utils/ | 85.59% | 95/111 | 68.25% | 43/63 | 94.74% | 18/19 | 85.59% | 95/111 | |
| src/ | 100% | 0/0 | 100% | 0/0 | 100% | 0/0 | 100% | 0/0 |


Introduction
Boto ships with a number of command line utilities, which are installed
when the package is installed. This guide outlines which ones are available
& what they do.
The included utilities available are:
- asadmin
- Works with Autoscaling
- bundle_image
- Creates a bundled AMI in S3 based on a EC2 instance
- cfadmin
- Works with CloudFront & invalidations
- cq
- Works with SQS queues
- cwutil
- Works with CloudWatch
dynamodb_dump
dynamodb_load
Handle dumping/loading data from DynamoDB tables
- elbadmin
- Manages Elastic Load Balancer instances
- fetch_file
- Downloads an S3 key to disk
- glacier
- Lists vaults, jobs & uploads files to Glacier
- instance_events
- Lists all events for EC2 reservations
- kill_instance
- Kills a list of EC2 instances
- launch_instance
- Launches an EC2 instance
- list_instances
- Lists all of your EC2 instances
- lss3
- Lists what keys you have within a bucket in S3
- mturk
- Provides a number of facilities for interacting with Mechanical Turk
- pyami_sendmail
- Sends an email from the Pyami instance
- route53
- Interacts with the Route53 service
- s3put
- Uploads a directory or a specific file(s) to S3
- sdbadmin
- Allows for working with SimpleDB domains
- taskadmin
- A tool for working with the tasks in SimpleDB


Hey! My name is Jenish Basnet. I am a B.S.C.(Hons)Computing student of Itahari International college.


It is an extension of 'lmom' R package: 'pel','cdf',qua' function families are lumped and called from one function per each family respectively in order to create robust automatic tools to fit data with different probability distributions and then to estimate probability values and return periods. The implemented functions are able to manage time series with constant and/or missing values without stopping the execution with error messages. The package also contains tools to calculate several indices based on variability (e.g. 'SPI' , Standardized Precipitation Index, see <https://climatedataguide.ucar.edu/climate-data/standardized-precipitation-index-spi> and <http://spei.csic.es/>) for multiple time series or spatio-temporal gridded values.
| Version: | 0.5.0 |
| Depends: | R (≥ 3.0.1), lmom, stringr |
| Suggests: | rasterList, lmomRFA, SPEI |
| Published: | 2017-11-29 |
| Author: | Emanuele Cordano, Unit D.02 Water and Marine Resources,Joint Research Centre of the European Commission |
| Maintainer: | Emanuele Cordano <emanuele.cordano at ext.ec.europa.eu> |
| License: | GPL (≥ 3) |
| NeedsCompilation: | no |
| CRAN checks: | lmomPi results |
| Reference manual: | lmomPi.pdf |
| Package source: | lmomPi_0.5.0.tar.gz |
| Windows binaries: | r-devel: lmomPi_0.5.0.zip, r-release: lmomPi_0.5.0.zip, r-oldrel: lmomPi_0.5.0.zip |
| OS X binaries: | r-release: lmomPi_0.5.0.tgz, r-oldrel: lmomPi_0.5.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=lmomPi to link to this page.


Test Steps
- Copy the 'cordova-usecase-android-tests/tests/CordovaPackage/res/test.py' file to crosswalk-cordova directory
- Run the python script:
$ python test.py - Check the command output
- Quick press back button to exit 'hello' app after the app launch
Purpose:
Verify the Cordova package can build, install and launch successfully
Expected Results:
- There has test.py in crosswalk-cordova directory
- The command run successfully, no error
- Display 'Build Package Successfully' and 'Package Name Consistent'
- The app can exit successfully


The Basics
dred is a simple text editor which generally follows the convensions employed by most Windows based text editing tools. The following is
a quick list detailing basic functionality that differs from the standard features found in other editors.
- Use the ESC key to activate/deactivate the command bar
- Config files are stored in %APPDATA%/dred on Windows and ~/.config/dred on Linux
- A full list of supported config variables can be found here: Config variables
- Config files are implemented as .dred files with each property being a simple key/value pair.
- When dred is run, it first loads the config file in the user directory if it exists.
- After the main config in the user directory dred will look for a .dred file in the directory dred is run from.
- Use the "include" statement to load configs within configs. This is useful for things like themes.
- Commands can be executed from within the config file with the "exec" statement.
- Commands can be assigned to an accelerator (keyboard shortcut) with the "bind" command.
- Example:
bind "Compile" "CTRL+F9" "!gcc %"


CONTINUE(7f) - [FORTRAN:EXECUTION CONTROL] construct (LICENSE:PD)
Synopsis
Description
Example
continue
Execution of a CONTINUE statement has no effect. A CONTINUE statement is most often used as a labeled line that is used in transfer control statements to numerically labeled lines such as GOTO. It is often very confusing to have executable statements on labeled lines; a CONTINUE statement eliminates the ambiguities that arise in jumping to an executable line. Preferably no target of a transfer should be an executable statement, but should be a statement like ENDDO or CONTINUE.CONTINUE was very frequently used as the end of a DO loop; ENDDO is now the proper way to end a DO loop.
program demo_continue I=10 J=5 if(I.lt.5)goto 100 J=3 100 continue write(*,*)J=,Jend program demo_continue
| Fortran | CONTINUE (7) | January 2017 |


When you've got the world's greatest basketball superstars and the world's greatest cartoon characters facing off against space aliens, you can't skimp on the jams -- and sure enough, Warner Sunset/Atlantic Records' Space Jam: Music From The Motion Picture is one of the most powerful collections in the universe.


Home
About the River
News
Events
Links
Board & Staff
How to Help
Protecting & Restoring the Rahway River and its Watershed
RAHWAY RIVER WATERSHED ASSOCIATION
Get Involved


{% extends "_base.html" %} {% load static %} {% block title %} Start | eSplash {% endblock %} {% block banner %} {#
Over 25 million Australians are
now without water.
You're one of them.
You don't have any water in
reserve for months.
And you're down to your last
10 buckets (i.e. 100 litres) of
water for the next 7 days.