def load_str(self, string):
err = Error()
strg = Str(str(string.encode("utf-8")))
rval = gtlib.gt_style_load_str(self.style, strg._as_parameter_,
err._as_parameter_)
if rval != 0:
gterror(err)
def mirror(self):
if self.is_mirrored():
gterror("encoded sequence is already mirrored")
err = Error()
ret = gtlib.gt_encseq_mirror(self.encseq, err.error)
if ret != 0:
gterror(err)
def __init__(self):
err = Error()
ads = gtlib.gt_anno_db_gfflike_new()
if ads == None:
gterror(err)
self.ads = ads
self._as_parameter_ = self.ads
def to_file(self, filename):
err = Error()
rval = gtlib.gt_canvas_cairo_file_to_file(
self.canvas,
str(filename).encode('UTF-8'), err)
if rval != 0:
gterror(err)
def get_height(self):
err = Error()
height = c_ulong()
gtlib.gt_layout_get_height(self.layout, byref(height), err)
if err.is_set():
gterror(err)
return height.value
def __init__(self, filename):
err = Error()
rdb = gtlib.gt_rdb_sqlite_new(filename, err._as_parameter_)
if rdb == None:
gterror(err)
self.rdb = rdb
self._as_parameter_ = self.rdb
def to_str(self):
err = Error()
string = Str()
if gtlib.gt_style_to_str(self.style, string, err) == 0:
return str(string)
else:
gterror(err)
def encode(self, seqfiles, indexname):
if not isinstance(seqfiles, list):
raise TypeError("argument must be a list of strings")
if len(seqfiles) == 0:
raise Error("list of input sequence files must be non-empty")
sa = StrArray()
for f in seqfiles:
if not os.path.exists(str(f)):
raise IOError("file not found: %s" % str(f))
sa.add(str(f))
err = Error()
esptr = gtlib.gt_encseq_encoder_encode(self.ee, sa.strarr,
str(indexname).encode("UTF-8"),
err.error)
if esptr != 0:
gterror(err)
def get_first_seqid(self):
err = Error()
str = gtlib.gt_feature_index_get_first_seqid(self.fi, err)
if str == None:
if err.is_set():
gterror(err)
return str
def add_gff3file(self, filename):
err = Error()
rval = gtlib.gt_feature_index_add_gff3file(self.fi,
filename.encode('UTF-8'),
err)
if rval != 0:
gterror(err)
def __init__(self, diagram, width, style):
err = Error()
self.layout = gtlib.gt_layout_new(diagram._as_parameter_, width,
style._as_parameter_,
err._as_parameter_)
if err.is_set():
gterror(err)
self._as_parameter_ = self.layout
def to_str(self):
err = Error()
string = Str()
if gtlib.gt_style_to_str(self.style, string._as_parameter_,
err._as_parameter_) == 0:
return str(string)
else:
gterror(err)
def get_feature_index(self, rdb):
err = Error()
fi = gtlib.gt_anno_db_schema_get_feature_index(self.ads,
rdb._as_parameter_,
err._as_parameter_)
if fi == None:
gterror(err)
return FeatureIndexFromPtr(fi)
def __init__(self, style, width, height, ii=None):
err = Error()
canvas = gtlib.gt_canvas_cairo_file_new(style, GRAPHICS_PNG, width,
height, ii, err)
if canvas == None:
gterror(err)
self.canvas = canvas
self._as_parameter_ = self.canvas
def get_first_seqid(self):
err = Error()
str = gtlib.gt_feature_index_get_first_seqid(self.fi,
err._as_parameter_)
if str == None:
if err.is_set():
gterror(err)
return str.decode('UTF-8')
def get_seqids(self):
result = []
err = Error()
stra = StrArray(gtlib.gt_feature_index_get_seqids(self.fi, err))
if stra == None:
gterror(err)
for i in range(stra.size()):
result.append(stra.get(i))
return result
def has_seqid(self, seqid):
from ctypes import c_int, byref
val = c_int()
err = Error()
ret = gtlib.gt_feature_index_has_seqid(self.fi, byref(val), seqid, err)
if ret != 0:
gterror(err)
else:
return (val.value > 0)
def create_from_file(indexname):
if not os.path.exists(indexname + ".al1"):
raise IOError, ("file not found: %s" % (indexname + ".al1"))
e = Error()
a_ptr = gtlib.gt_alphabet_new_from_file(str(indexname), e)
a = Alphabet(a_ptr, True)
if a == None:
gterror(e)
else:
return a
def from_index(feature_index, seqid, rng, style):
from ctypes import byref
err = Error()
if rng.start > rng.end:
gterror("range.start > range.end")
diagram = gtlib.gt_diagram_new(feature_index, seqid, byref(rng), style,
err)
if err.is_set():
gterror(err)
return Diagram(diagram)
def next_tree(self):
err = Error()
genome_node = c_void_p()
rval = gtlib.gt_node_stream_next(self.gs, byref(genome_node), err)
if rval != 0:
gterror(err)
if genome_node.value == None:
return None
else:
return GenomeNode.create_from_ptr(genome_node.value)
def __init__(self, ptr=None):
if ptr:
self.style = ptr
self.own = False
else:
e = Error()
self.style = gtlib.gt_style_new(e)
if self.style == 0 or self.style == None:
gterror(e)
self.own = True
self._as_parameter_ = self.style
def get_cstr(self, section, key, gn=None):
string = Str()
err = Error()
rval = gtlib.gt_style_get_str(self.style, section, key, string, gn,
err)
if rval == STYLE_OK:
return str(string)
elif rval == STYLE_NOT_SET:
return None
elif rval == STYLE_ERROR:
gterror(err)
def has_seqid(self, seqid):
from ctypes import c_int, byref
val = c_int()
err = Error()
ret = gtlib.gt_feature_index_has_seqid(self.fi, byref(val),
seqid.encode('UTF-8'),
err._as_parameter_)
if ret != 0:
gterror(err)
else:
return (val.value > 0)
def get_range_for_seqid(self, seqid):
from ctypes import byref
err = Error()
if self.has_seqid(seqid) == 0:
gterror("feature_index does not contain seqid")
range = Range()
rval = gtlib.gt_feature_index_get_range_for_seqid(
self.fi, byref(range), seqid.encode('UTF-8'), err)
if rval != 0:
gterror(err)
return range
def get_color(self, section, key, gn=None):
from ctypes import byref
color = Color()
err = Error()
rval = gtlib.gt_style_get_color(self.style, section, key, byref(color),\
gn, err)
if rval == STYLE_OK:
return color
elif rval == STYLE_NOT_SET:
return None
elif rval == STYLE_ERROR:
gterror(err)
def feature_node_w(fn_p, err_p):
fn = FeatureNode.create_from_ptr(fn_p)
err = Error(err_p)
try:
try:
self.visit_feature_node(fn)
except AttributeError:
pass
return 0
except GTError, errmsg:
err.set(str(errmsg))
return -1
def get_num(self, section, key, gn=None):
from ctypes import c_double, byref
double = c_double()
err = Error()
rval = gtlib.gt_style_get_num(self.style, section, key, byref(double), \
gn, err)
if rval == STYLE_OK:
return double.value
elif rval == STYLE_NOT_SET:
return None
elif rval == STYLE_ERROR:
gterror(err)
def sequence_node_w(sn_p, err_p):
sn = SequenceNode.create_from_ptr(sn_p)
err = Error(err_p)
try:
try:
self.visit_sequence_node(sn)
except AttributeError:
pass
return 0
except GTError, errmsg:
err.set(str(errmsg))
return -1
def region_node_w(rn_p, err_p):
rn = RegionNode.create_from_ptr(rn_p)
err = Error(err_p)
try:
try:
self.visit_region_node(rn)
except AttributeError:
pass
return 0
except GTError, errmsg:
err.set(str(errmsg))
return -1
def comment_node_w(cn_p, err_p):
cn = CommentNode.create_from_ptr(cn_p)
err = Error(err_p)
try:
try:
self.visit_comment_node(cn)
except AttributeError:
pass
return 0
except GTError, errmsg:
err.set(str(errmsg))
return -1
