def model_to_owl(model, fname):
"""Save a BioPAX model object as an OWL file.
Parameters
----------
model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
fname : str
The name of the OWL file to save the model in.
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
fileOS = autoclass('java.io.FileOutputStream')(fname)
except JavaException:
logger.error('Could not open data file %s' % fname)
return
l3_factory = autoclass(
'org.biopax.paxtools.model.BioPAXLevel').L3.getDefaultFactory()
model_out = l3_factory.createModel()
for r in model.getObjects().toArray():
model_out.add(r)
io.convertToOWL(model_out, fileOS)
fileOS.close()
def owl_to_model(fname):
"""Return a BioPAX model object from an OWL file.
Parameters
----------
fname : str
The name of the OWL file containing the model.
Returns
-------
biopax_model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
file_is = autoclass('java.io.FileInputStream')(fname)
except JavaException:
logger.error('Could not open data file %s' % fname)
return
try:
biopax_model = io.convertFromOWL(file_is)
except JavaException as e:
logger.error('Could not convert data file %s to BioPax model' % fname)
logger.error(e)
return
file_is.close()
return biopax_model
def model_to_owl(model, fname):
"""Save a BioPAX model object as an OWL file.
Parameters
----------
model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
fname : str
The name of the OWL file to save the model in.
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
fileOS = autoclass('java.io.FileOutputStream')(fname)
except JavaException:
logger.error('Could not open data file %s' % fname)
return
l3_factory = autoclass('org.biopax.paxtools.model.BioPAXLevel').L3.getDefaultFactory()
model_out = l3_factory.createModel()
for r in model.getObjects().toArray():
model_out.add(r)
io.convertToOWL(model_out, fileOS)
fileOS.close()
def process_text(self, text, format='json'):
"""Return a mentions JSON object given text.
Parameters
----------
text : str
Text to be processed.
format : str
The format of the output to produce, one of "json" or "json_ld".
Default: "json"
Returns
-------
json_dict : dict
A JSON object of mentions extracted from text.
"""
if self.eidos_reader is None:
eidos = autoclass(eidos_package + '.EidosSystem')
self.eidos_reader = eidos(autoclass('java.lang.Object')())
annot_doc = self.eidos_reader.extractFromText(text, False, False)
if format == 'json':
mentions = annot_doc.odinMentions()
ser = autoclass(eidos_package +
'.serialization.json.WMJSONSerializer')
mentions_json = ser.toJsonStr(mentions)
elif format == 'json_ld':
# We need to get a Scala Seq of annot docs here
ml = autoclass('scala.collection.mutable.MutableList')()
ml.appendElem(annot_doc)
jc = autoclass(eidos_package + '.serialization.json.JLDCorpus')
corpus = jc(ml, self.eidos_reader)
mentions_json = corpus.toJsonStr()
json_dict = json.loads(mentions_json)
return json_dict
def owl_to_model(fname):
"""Return a BioPAX model object from an OWL file.
Parameters
----------
fname : str
The name of the OWL file containing the model.
Returns
-------
biopax_model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
file_is = autoclass('java.io.FileInputStream')(fname)
except JavaException:
logger.error('Could not open data file %s' % fname)
return
try:
biopax_model = io.convertFromOWL(file_is)
except JavaException as e:
logger.error('Could not convert data file %s to BioPax model' % fname)
logger.error(e)
return
file_is.close()
return biopax_model
def _run_pc_query(query_type, gene_names, neighbor_limit=1):
cpath_client = autoclass('cpath.client.CPathClient').\
newInstance('http://www.pathwaycommons.org/pc2/')
query = cpath_client.createGraphQuery()
query.kind(query_type)
query.sources(gene_names)
query.organismFilter(['h**o sapiens'])
query.mergeEquivalentInteractions(True)
query.limit(autoclass('java.lang.Integer')(neighbor_limit))
# Execute query
model = query.result()
return model
def _run_pc_query(query_type, source_genes, target_genes=None, neighbor_limit=1):
cpath_client = autoclass('cpath.client.CPathClient').\
newInstance('http://www.pathwaycommons.org/pc2/')
query = cpath_client.createGraphQuery()
query.kind(query_type)
query.sources(source_genes)
query.targets(target_genes)
query.organismFilter(['h**o sapiens'])
query.mergeEquivalentInteractions(True)
query.limit(autoclass('java.lang.Integer')(neighbor_limit))
# Execute query
model = query.result()
return model
def process_text(self, text, format='json'):
"""Return a mentions JSON object given text.
Parameters
----------
text : str
Text to be processed.
format : str
The format of the output to produce, one of "json" or "json_ld".
Default: "json"
Returns
-------
json_dict : dict
A JSON object of mentions extracted from text.
"""
if self.eidos_reader is None:
self.initialize_reader()
default_arg = lambda x: autoclass('scala.Some')(x)
today = datetime.date.today().strftime("%Y-%m-%d")
fname = 'default_file_name'
annot_doc = self.eidos_reader.extractFromText(
text,
True, # keep text
False, # CAG-relevant only
default_arg(today), # doc creation time
default_arg(fname) # file name
)
if format == 'json':
mentions = annot_doc.odinMentions()
ser = autoclass(eidos_package +
'.serialization.json.WMJSONSerializer')
mentions_json = ser.toJsonStr(mentions)
elif format == 'json_ld':
# We need to get a Scala Seq of annot docs here
ml = _list_to_seq([annot_doc])
# We currently do not need toinstantiate the adjective grounder
# if we want to reinstate it, we would need to do the following
# ag = EidosAdjectiveGrounder.fromConfig(
# EidosSystem.defaultConfig.getConfig("adjectiveGrounder"))
# We now create a JSON-LD corpus
jc = autoclass(eidos_package + '.serialization.json.JLDCorpus')
corpus = jc(ml)
# Finally, serialize the corpus into JSON string
mentions_json = corpus.toJsonStr()
json_dict = json.loads(mentions_json)
return json_dict
def model_to_owl(model, fname):
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
fileOS = autoclass('java.io.FileOutputStream')(fname)
except JavaException:
print 'Could not open data file %s' % fname
return
l3_factory = autoclass('org.biopax.paxtools.model.BioPAXLevel').L3.getDefaultFactory()
model_out = l3_factory.createModel()
for r in model.getObjects().toArray():
model_out.add(r)
io.convertToOWL(model_out, fileOS)
fileOS.close()
def process_nxml(file_name, use_tempdir=False, offline=False):
if offline:
base = os.path.basename(file_name)
file_id = os.path.splitext(base)[0]
if use_tempdir:
tmp_dir = tempfile.mkdtemp()
else:
tmp_dir = '.'
try:
paper_reader = autoclass('edu.arizona.sista.reach.ReadPaper')
paper_reader.main([file_name, tmp_dir])
except JavaException:
print 'Could not process file %s.' % file_name
return None
json_file_name = os.path.join(tmp_dir, file_id + '.uaz.events.json')
return process_json_file(json_file_name)
else:
url = 'http://agathon.sista.arizona.edu:8080/odinweb/api/nxml'
txt = open(file_name, 'rt').read()
req = urllib2.Request(url, data=urllib.urlencode({'nxml': txt}))
res = urllib2.urlopen(req)
json_str = res.read()
with open('reach_output.json', 'wt') as fh:
fh.write(json_str)
json_dict = json.loads(json_str)
return process_json_str(json_str, events_only=False)
def autoclass_robust(path):
try:
cl = autoclass(path)
except JavaException:
print 'Could not instantiate ' + path
return None
return cl
def _autoclass_robust(path):
try:
cl = autoclass(path)
except JavaException:
logger.error('Could not instantiate ' + path)
return None
return cl
def model_to_owl(model, fname):
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
fileOS = autoclass('java.io.FileOutputStream')(fname)
except JavaException:
print 'Could not open data file %s' % fname
return
l3_factory = autoclass('org.biopax.paxtools.model.BioPAXLevel').L3.getDefaultFactory()
model_out = l3_factory.createModel()
for r in model.getObjects().toArray():
model_out.add(r)
io.convertToOWL(model_out, fileOS)
fileOS.close()
def _autoclass_robust(path):
try:
cl = autoclass(path)
except JavaException:
logger.error('Could not instantiate ' + path)
return None
return cl
def autoclass_robust(path):
try:
cl = autoclass(path)
except JavaException:
print 'Could not instantiate ' + path
return None
return cl
def owl_to_model(fname):
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
file_is = autoclass('java.io.FileInputStream')(fname)
except JavaException:
print 'Could not open data file %s' % fname
return
try:
biopax_model = io.convertFromOWL(file_is)
except JavaException:
print 'Could not convert data file %s to BioPax model' % data_file
return
file_is.close()
return biopax_model
def owl_to_model(fname):
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
try:
file_is = autoclass('java.io.FileInputStream')(fname)
except JavaException:
print 'Could not open data file %s' % fname
return
try:
biopax_model = io.convertFromOWL(file_is)
except JavaException:
print 'Could not convert data file %s to BioPax model' % data_file
return
file_is.close()
return biopax_model
def get_api_ruler(self):
"""Return the existing reader if it exists or launch a new one.
Returns
-------
api_ruler : edu.arizona.sista.reach.apis.ApiRuler
An instance of the REACH ApiRuler class (java object).
"""
if self.api_ruler is None:
try:
self.api_ruler =\
autoclass('edu.arizona.sista.reach.apis.ApiRuler')
except JavaException:
try:
autoclass('java.lang.String')
except JavaException:
pass
return None
return self.api_ruler
def owl_str_to_model(owl_str):
"""Return a BioPAX model object from an OWL string.
Parameters
----------
owl_str : str
The model as an OWL string.
Returns
-------
biopax_model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
bais = autoclass('java.io.ByteArrayInputStream')
scs = autoclass('java.nio.charset.StandardCharsets')
jstr = autoclass('java.lang.String')
istream = bais(owl_str)
biopax_model = io.convertFromOWL(istream)
return biopax_model
def owl_str_to_model(owl_str):
"""Return a BioPAX model object from an OWL string.
Parameters
----------
owl_str : str
The model as an OWL string.
Returns
-------
biopax_model : org.biopax.paxtools.model.Model
A BioPAX model object (java object).
"""
io_class = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
io = io_class(autoclass('org.biopax.paxtools.model.BioPAXLevel').L3)
bais = autoclass('java.io.ByteArrayInputStream')
scs = autoclass('java.nio.charset.StandardCharsets')
jstr = autoclass('java.lang.String')
istream = bais(owl_str)
biopax_model = io.convertFromOWL(istream)
return biopax_model
def get_api_ruler(self):
"""Return the existing reader if it exists or launch a new one.
Returns
-------
api_ruler : org.clulab.reach.apis.ApiRuler
An instance of the REACH ApiRuler class (java object).
"""
if self.api_ruler is None:
try:
self.api_ruler = \
autoclass('org.clulab.reach.export.apis.ApiRuler')
except JavaException:
# This second autoclass is needed because of a jnius
# issue in which the first JavaException is not raised.
try:
autoclass('java.lang.String')
except JavaException as e:
logger.error(e)
pass
return None
return self.api_ruler
def process_text(self, text):
"""Return a mentions JSON object given text.
Parameters
----------
text : str
Text to be processed.
Returns
-------
json_dict : dict
A JSON object of mentions extracted from text.
"""
if self.eidos_reader is None:
eidos = autoclass('org.clulab.wm.AgroSystem')
self.eidos_reader = eidos(autoclass('java.lang.Object')())
mentions = self.eidos_reader.extractFrom(text)
ser = autoclass('org.clulab.wm.serialization.json.WMJSONSerializer')
mentions_json = ser.toJsonStr(mentions)
json_dict = json.loads(mentions_json)
return json_dict
def get_api_ruler(self):
"""Return the existing reader if it exists or launch a new one.
Returns
-------
api_ruler : org.clulab.reach.apis.ApiRuler
An instance of the REACH ApiRuler class (java object).
"""
if self.api_ruler is None:
try:
self.api_ruler = \
autoclass('org.clulab.reach.export.apis.ApiRuler')
except JavaException:
# This second autoclass is needed because of a jnius
# issue in which the first JavaException is not raised.
try:
autoclass('java.lang.String')
except JavaException as e:
logger.error(e)
pass
return None
return self.api_ruler
def get_api_ruler(self):
"""Return the existing reader if it exists or launch a new one.
Returns
-------
api_ruler : org.clulab.reach.apis.ApiRuler
An instance of the REACH ApiRuler class (java object).
"""
if self.api_ruler is None:
try:
self.api_ruler = \
autoclass('org.clulab.reach.export.apis.ApiRuler')
except JavaException as e:
raise ReachOfflineReadingError(e)
return self.api_ruler
def get_api_ruler(self):
"""Return the existing reader if it exists or launch a new one.
Returns
-------
api_ruler : org.clulab.reach.apis.ApiRuler
An instance of the REACH ApiRuler class (java object).
"""
if self.api_ruler is None:
try:
self.api_ruler = \
autoclass('org.clulab.reach.export.apis.ApiRuler')
except JavaException as e:
raise ReachOfflineReadingError(e)
return self.api_ruler
def process_nxml(file_name, use_tempdir=False):
base = os.path.basename(file_name)
file_id = os.path.splitext(base)[0]
if use_tempdir:
tmp_dir = tempfile.mkdtemp()
else:
tmp_dir = '.'
try:
paper_reader = autoclass('edu.arizona.sista.bionlp.ReadPaper')
paper_reader.main([file_name, tmp_dir, _nxml_fries_path])
except JavaException:
print 'Could not process file %s.' % file_name
return None
json_file_name = os.path.join(tmp_dir, file_id + '.uaz.events.json')
return process_json_file(json_file_name)
def process_nxml(file_name, use_tempdir=False, offline=False):
if offline:
try:
api_ruler = autoclass('edu.arizona.sista.reach.apis.ApiRuler')
result_map = api_ruler.annotateNxml(file_name, 'fries')
except JavaException:
print 'Could not process file %s.' % file_name
return None
json_str = result_map.get('resultJson')
else:
url = 'http://agathon.sista.arizona.edu:8080/odinweb/api/nxml'
txt = open(file_name, 'rt').read()
req = urllib2.Request(url, data=urllib.urlencode({'nxml': txt}))
res = urllib2.urlopen(req)
json_str = res.read()
with open('reach_output.json', 'wt') as fh:
fh.write(json_str)
return process_json_str(json_str)
def process_nxml(file_name, use_tempdir=False, offline=False):
if offline:
try:
api_ruler = autoclass('edu.arizona.sista.reach.apis.ApiRuler')
result_map = api_ruler.annotateNxml(file_name, 'fries')
except JavaException:
print 'Could not process file %s.' % file_name
return None
json_str = result_map.get('resultJson')
else:
url = 'http://agathon.sista.arizona.edu:8080/odinweb/api/nxml'
txt = open(file_name, 'rt').read()
req = urllib2.Request(url, data=urllib.urlencode({'nxml': txt}))
res = urllib2.urlopen(req)
json_str = res.read()
with open('reach_output.json', 'wt') as fh:
fh.write(json_str)
return process_json_str(json_str)
def process_text(self, text, format='json'):
"""Return a mentions JSON object given text.
Parameters
----------
text : str
Text to be processed.
format : str
The format of the output to produce, one of "json" or "json_ld".
Default: "json"
Returns
-------
json_dict : dict
A JSON object of mentions extracted from text.
"""
if self.eidos_reader is None:
eidos = autoclass(eidos_package + '.EidosSystem')
self.eidos_reader = eidos(autoclass('java.lang.Object')())
default_arg = lambda x: autoclass('scala.Some')(x)
today = datetime.date.today().strftime("%Y-%m-%d")
fname = 'default_file_name'
annot_doc = self.eidos_reader.extractFromText(
text,
True, # keep text
False, # CAG-relevant only
default_arg(today), # doc creation time
default_arg(fname) # file name
)
if format == 'json':
mentions = annot_doc.odinMentions()
ser = autoclass(eidos_package +
'.serialization.json.WMJSONSerializer')
mentions_json = ser.toJsonStr(mentions)
elif format == 'json_ld':
# We need to get a Scala Seq of annot docs here
ml = autoclass('scala.collection.mutable.MutableList')()
# We add the document to the mutable list
ml.appendElem(annot_doc)
# We instantiate the adjective grounder
ag = self.eidos_reader.loadableAttributes().adjectiveGrounder()
# We now create a JSON-LD corpus
jc = autoclass(eidos_package + '.serialization.json.JLDCorpus')
corpus = jc(ml, ag)
# Finally, serialize the corpus into JSON string
mentions_json = corpus.toJsonStr()
json_dict = json.loads(mentions_json)
return json_dict
def test_cpath_autoclass():
autoclass('cpath.client.CPathClient')
def test_biopaxpattern_autoclass():
autoclass('org.biopax.paxtools.pattern.PatternBox')
def test_paxtools_autoclass():
autoclass('org.biopax.paxtools.impl.level3.ProteinImpl')
def initialize_reader(self):
"""Instantiate the Eidos reader attribute of this reader."""
eidos = autoclass(eidos_package + '.EidosSystem')
self.eidos_reader = eidos()
def process_pc_pathsbetween(gene_names, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').PATHSBETWEEN
model = _run_pc_query(query_type, gene_names, None, neighbor_limit)
if model is not None:
return process_model(model)
def process_pc_pathsbetween(gene_names, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').PATHSBETWEEN
model = _run_pc_query(query_type, gene_names, None, neighbor_limit)
if model is not None:
return process_model(model)
def process_pc_pathsfromto(source_genes, target_genes, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').PATHSFROMTO
model = _run_pc_query(query_type, source_genes, target_genes,
neighbor_limit)
if model is not None:
return process_model(model)
def test_cpath_autoclass():
autoclass('cpath.client.CPathClient')
def test_biopaxpattern_autoclass():
autoclass('org.biopax.paxtools.pattern.PatternBox')
def test_paxtools_autoclass():
autoclass('org.biopax.paxtools.impl.level3.ProteinImpl')
def process_pc_neighborhood(gene_names, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').NEIGHBORHOOD
model = _run_pc_query(query_type, gene_names, None, neighbor_limit)
if model is not None:
return process_model(model)
def process_pc_neighborhood(gene_names, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').NEIGHBORHOOD
model = _run_pc_query(query_type, gene_names, None, neighbor_limit)
if model is not None:
return process_model(model)
from indra.java_vm import autoclass, cast
import heapq
from .sbgn import get_default_bbox
DEFAULT_MAX_CONVERSIONS = 20
REACTOME_NAME = 'reactome'
CTD_NAME = 'ctd'
PID_NAME = 'pid'
PANTHER_NAME = 'panther'
JHashSet = autoclass('java.util.HashSet')
JString = autoclass('java.lang.String')
JL3ToSBGNPDConverter = autoclass('org.biopax.paxtools.io.sbgn.L3ToSBGNPDConverter')
JByteArrayOutputStream = autoclass('java.io.ByteArrayOutputStream')
JStandardCharsets = autoclass('java.nio.charset.StandardCharsets')
JCompleter = autoclass('org.biopax.paxtools.controller.Completer')
JSimpleEditorMap = autoclass('org.biopax.paxtools.controller.SimpleEditorMap')
JCloner = autoclass('org.biopax.paxtools.controller.Cloner')
JBioPAXLevel = autoclass('org.biopax.paxtools.model.BioPAXLevel')
JSimpleIOHandler = autoclass('org.biopax.paxtools.io.SimpleIOHandler')
JModel = autoclass('org.biopax.paxtools.model.Model')
JConversion = autoclass('org.biopax.paxtools.model.level3.Conversion')
JByteArrayInputStream = autoclass('java.io.ByteArrayInputStream')
JBbox = autoclass('org.sbgn.bindings.Bbox')
JMarshaller = autoclass('javax.xml.bind.Marshaller')
JAXBContext = autoclass('javax.xml.bind.JAXBContext')
JBoolean = autoclass('java.lang.Boolean')
def datasource_score(jConversion):
ds = get_datasource(jConversion)
reverse_importance_order = [PANTHER_NAME, PID_NAME, CTD_NAME, REACTOME_NAME]
def process_pc_pathsfromto(source_genes, target_genes, neighbor_limit=1):
query_type = autoclass('cpath.service.GraphType').PATHSFROMTO
model = _run_pc_query(query_type, source_genes, target_genes, neighbor_limit)
if model is not None:
return process_model(model)
import sys
import os
from os.path import join, dirname, abspath
from indra import preassembler
from indra.sources import eidos
from indra.sources.hume.make_hume_tsv import make_file as mht
from indra.sources.sofia.make_sofia_tsv import make_file as mst
from indra.java_vm import autoclass
eidos_package = 'org.clulab.wm.eidos'
if __name__ == '__main__':
sofia_ont_path = sys.argv[1]
hume_path = 'hume_ontology_examples.tsv'
mht(hume_path)
sofia_path = 'sofia_ontology_examples.tsv'
mst(sofia_ont_path, sofia_path)
om = autoclass(eidos_package + '.apps.OntologyMapper')
eidos = autoclass(eidos_package + '.EidosSystem')
es = eidos(autoclass('java.lang.Object')())
example_weight = 0.8
parent_weight = 0.1
topn = 10
table_str = om.mapOntologies(es, hume_path, sofia_path, example_weight,
parent_weight, topn)
with open(join(dirname(abspath(__file__)), os.pardir, 'resources',
'wm_ontomap.tsv'), 'w') as fh:
fh.write(table_str)
import os
from os.path import join, dirname, abspath
from indra import preassembler
from indra.sources import eidos
from indra.sources.hume.make_hume_tsv import make_file as mht
from indra.sources.sofia.make_sofia_tsv import make_file as mst
from indra.java_vm import autoclass
eidos_package = 'org.clulab.wm.eidos'
if __name__ == '__main__':
sofia_ont_path = sys.argv[1]
hume_path = 'hume_ontology_examples.tsv'
mht(hume_path)
sofia_path = 'sofia_ontology_examples.tsv'
mst(sofia_ont_path, sofia_path)
om = autoclass(eidos_package + '.apps.OntologyMapper')
eidos = autoclass(eidos_package + '.EidosSystem')
es = eidos(autoclass('java.lang.Object')())
example_weight = 0.8
parent_weight = 0.1
topn = 10
table_str = om.mapOntologies(es, hume_path, sofia_path, example_weight,
parent_weight, topn)
with open(
join(dirname(abspath(__file__)), os.pardir, 'resources',
'wm_ontomap.tsv'), 'w') as fh:
fh.write(table_str)
def _list_to_seq(lst):
"""Return a scala.collection.Seq from a Python list."""
ml = autoclass('scala.collection.mutable.MutableList')()
for element in lst:
ml.appendElem(element)
return ml
