Back to index

python-biopython  1.60
Public Member Functions | Public Attributes | Private Member Functions
Bio.KEGG.Enzyme.Record Class Reference

List of all members.

Public Member Functions

def __init__
def __str__

Public Attributes

 entry
 name
 classname
 sysname
 reaction
 substrate
 product
 inhibitor
 cofactor
 effector
 comment
 pathway
 genes
 disease
 structures
 dblinks

Private Member Functions

def _entry
def _name
def _classname
def _sysname
def _reaction
def _substrate
def _product
def _inhibitor
def _cofactor
def _effector
def _comment
def _pathway
def _genes
def _disease
def _structures
def _dblinks

Detailed Description

Holds info from a KEGG Enzyme record.

Members:
entry       The EC number (withou the 'EC ').
name        A list of the enzyme names.
classname   A list of the classification terms.
sysname     The systematic name of the enzyme.
reaction    A list of the reaction description strings.
substrate   A list of the substrates.
product     A list of the products.
inhibitor   A list of the inhibitors.
cofactor    A list of the cofactors.
effector    A list of the effectors.
comment     A list of the comment strings.
pathway     A list of 3-tuples: (database, id, pathway)
genes       A list of 2-tuples: (organism, list of gene ids)
disease     A list of 3-tuples: (database, id, disease)
structures  A list of 2-tuples: (database, list of struct ids)
dblinks     A list of 2-tuples: (database, list of db ids)

Definition at line 35 of file __init__.py.


Constructor & Destructor Documentation

__init___(self)

Create a new Record.

Definition at line 56 of file __init__.py.

00056 
00057     def __init__(self):
00058         """__init___(self)
00059 
00060         Create a new Record.
00061         """
00062         self.entry      = ""
00063         self.name       = []
00064         self.classname  = []
00065         self.sysname    = []
00066         self.reaction   = []
00067         self.substrate  = []
00068         self.product    = []
00069         self.inhibitor  = []
00070         self.cofactor   = []
00071         self.effector   = []
00072         self.comment    = []
00073         self.pathway    = []
00074         self.genes      = []
00075         self.disease    = []
00076         self.structures = []
        self.dblinks    = []

Here is the caller graph for this function:


Member Function Documentation

__str__(self)

Returns a string representation of this Record.

Definition at line 77 of file __init__.py.

00077 
00078     def __str__(self):
00079         """__str__(self)
00080 
00081         Returns a string representation of this Record.
00082         """
00083         return self._entry() + \
00084                self._name()  + \
00085                self._classname() + \
00086                self._sysname() + \
00087                self._reaction() + \
00088                self._substrate() + \
00089                self._product() + \
00090                self._inhibitor() + \
00091                self._cofactor() + \
00092                self._effector() + \
00093                self._comment() + \
00094                self._pathway() + \
00095                self._genes() + \
00096                self._disease() + \
00097                self._structures() + \
00098                self._dblinks() + \
               "///"

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._classname (   self) [private]

Definition at line 106 of file __init__.py.

00106 
00107     def _classname(self):
00108         return _write_kegg("CLASS",
                           self.classname)

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._cofactor (   self) [private]

Definition at line 129 of file __init__.py.

00129 
00130     def _cofactor(self):
00131         return _write_kegg("COFACTOR",
00132                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.cofactor])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._comment (   self) [private]

Definition at line 137 of file __init__.py.

00137 
00138     def _comment(self):
00139         return _write_kegg("COMMENT",
00140                            [_wrap_kegg(l, wrap_rule = id_wrap(0)) \
                            for l in self.comment])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._dblinks (   self) [private]

Definition at line 169 of file __init__.py.

00169 
00170     def _dblinks(self):
00171         # This is a bit of a cheat that won't work if enzyme entries
00172         # have more than one link id per db id. For now, that's not
00173         # the case - storing links ids in a list is only to make
00174         # this class similar to the Compound.Record class.
00175         s = []
00176         for entry in self.dblinks:
00177             s.append(entry[0] + ": " + "  ".join(entry[1]))
00178         return _write_kegg("DBLINKS", s)
00179 
00180 

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._disease (   self) [private]

Definition at line 155 of file __init__.py.

00155 
00156     def _disease(self):
00157         s = []
00158         for entry in self.disease:
00159             s.append(entry[0] + ": " + entry[1] + "  " + entry[2])
00160         return _write_kegg("DISEASE",
00161                            [_wrap_kegg(l, wrap_rule = id_wrap(13)) \
                            for l in s])    

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._effector (   self) [private]

Definition at line 133 of file __init__.py.

00133 
00134     def _effector(self):
00135         return _write_kegg("EFFECTOR",
00136                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.effector])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._entry (   self) [private]

Definition at line 99 of file __init__.py.

00099 
00100     def _entry(self):
00101         return _write_kegg("ENTRY",
                           ["EC " + self.entry])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._genes (   self) [private]

Definition at line 148 of file __init__.py.

00148 
00149     def _genes(self):
00150         s = []
00151         for entry in self.genes:
00152             s.append(entry[0] + ": " + " ".join(entry[1]))
00153         return _write_kegg("GENES",
00154                            [_wrap_kegg(l, wrap_rule = id_wrap(5)) \
                            for l in s])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._inhibitor (   self) [private]

Definition at line 125 of file __init__.py.

00125 
00126     def _inhibitor(self):
00127         return _write_kegg("INHIBITOR",
00128                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.inhibitor])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._name (   self) [private]

Definition at line 102 of file __init__.py.

00102 
00103     def _name(self):
00104         return _write_kegg("NAME",
00105                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.name])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._pathway (   self) [private]

Definition at line 141 of file __init__.py.

00141 
00142     def _pathway(self):
00143         s = []
00144         for entry in self.pathway:
00145             s.append(entry[0] + ": " + entry[1] + "  " + entry[2])
00146         return _write_kegg("PATHWAY",
00147                            [_wrap_kegg(l, wrap_rule = id_wrap(16)) \
                            for l in s])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._product (   self) [private]

Definition at line 121 of file __init__.py.

00121 
00122     def _product(self):
00123         return _write_kegg("PRODUCT",
00124                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.product])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._reaction (   self) [private]

Definition at line 113 of file __init__.py.

00113 
00114     def _reaction(self):
00115         return _write_kegg("REACTION",
00116                            [_wrap_kegg(l, wrap_rule = rxn_wrap) \
                            for l in self.reaction])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._structures (   self) [private]

Definition at line 162 of file __init__.py.

00162 
00163     def _structures(self):
00164         s = []
00165         for entry in self.structures:
00166             s.append(entry[0] + ": " + "  ".join(entry[1]) + "  ")
00167         return _write_kegg("STRUCTURES",
00168                            [_wrap_kegg(l, wrap_rule = struct_wrap(5)) \
                            for l in s])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._substrate (   self) [private]

Definition at line 117 of file __init__.py.

00117 
00118     def _substrate(self):
00119         return _write_kegg("SUBSTRATE",
00120                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.substrate])

Here is the call graph for this function:

Here is the caller graph for this function:

def Bio.KEGG.Enzyme.Record._sysname (   self) [private]

Definition at line 109 of file __init__.py.

00109 
00110     def _sysname(self):
00111         return _write_kegg("SYSNAME",
00112                            [_wrap_kegg(l, wrap_rule = name_wrap) \
                            for l in self.sysname])

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 63 of file __init__.py.

Definition at line 69 of file __init__.py.

Definition at line 71 of file __init__.py.

Definition at line 76 of file __init__.py.

Definition at line 74 of file __init__.py.

Definition at line 70 of file __init__.py.

Definition at line 61 of file __init__.py.

Definition at line 73 of file __init__.py.

Definition at line 68 of file __init__.py.

Definition at line 62 of file __init__.py.

Definition at line 72 of file __init__.py.

Definition at line 67 of file __init__.py.

Definition at line 65 of file __init__.py.

Definition at line 75 of file __init__.py.

Definition at line 66 of file __init__.py.

Definition at line 64 of file __init__.py.


The documentation for this class was generated from the following file: