def createBlogData(blogFile=None):
if blogFile == None:
# edit temp blog data file
blogFile = NamedTemporaryFile(suffix='.txt', prefix='blogger_py')
editor = os.environ.get('EDITOR', Editor)
stat = os.spawnlp(os.P_WAIT, editor, editor, blogFile.name)
if stat != 0:
raise EditError, 'edit tempfile failed: %s %s' % \
(editor, blogFile.name)
# read blog data from temp file, publish a public post.
title = blogFile.readline().rstrip('\r\n')
label = blogFile.readline().strip()
if label == '':
_title = title.split(':') # title == 'LABEL: string'
if len(_title) >= 2:
label = _title[0]
content = blogFile.read()
_parts = docutils.core.publish_parts(source=content, writer_name='html')
body = _parts['body']
title = title.decode('utf-8')
saveBlogFile(blogFile.name)
blogFile.close() # blogFile will delete automatically
return title, body, label
def _regread(self,path):
"""Read contents of given key from the registry.
The result is a generator of (key,name,data,type) tuples. For
the keys themselves each of name, data and type will be None.
"""
tf = NamedTemporaryFile()
self._run_regedit("/E",tf.name,path)
tf.seek(0)
tf.readline()
(key,name,data,type) = (None,None,None,None)
for ln in tf:
if not ln:
continue
if ln.startswith("["):
key = ln.strip().strip("[]").strip("\"")
(name,data,type) = (None,None,None)
else:
val_re = r'^"?(\@|[^"]+)"?="?(([a-zA-Z0-9\(\)]+:)?)([^"]+)"?$'
m = re.match(val_re,ln.strip())
if not m:
continue
(name,type,_,data) = m.groups()
if name == "@":
name = ""
type = _unmap_type(type)
data = _unmap_data(data,type)
yield (key,name,data,type)
def Gtk2_GetSaveFilename(master, name, title, icon, **kw): ''' Calls Gnome open file dialog. Parameteres: master - parent window name - application name title - dialog title **kw: initialdir - absolute path to initial dir initialfile - file name Returns: tuple of utf8 and system encoded file names ''' initialdir = check_initialdir(kw['initialdir']) initialfile = '' if kw['initialfile']: initialfile = kw['initialfile'] filetypes = convert_for_gtk2(kw['filetypes']) name += ' - ' + title tmpfile = NamedTemporaryFile() execline = '' if sk1.LANG: execline += 'export LANG=' + sk1.LANG + ';' path = os.path.join(initialdir, initialfile) execline += 'python %s/gtk/save_file_dialog.py ' % (PATH,) execline += ' caption="' + name + '" path="' + path + '" ' execline += ' filetypes="' + filetypes + '" window-icon="' + icon + '"' os.system(execline + '>' + tmpfile.name) result = tmpfile.readline().strip() return (result, result)
def get_system_fonts():
"""
Returns list of four fonts, used in sK1 UI:
[small_font,normal_font,large_font,fixed_font]
Each font is a list like:
[font_family,font_style,font_size]
where:
font_family - string representation of font family
font_style - list of font styles like 'bold' and 'italic'
font_size - font size integer value
Currently Gtk binding is implemented. Win32 and MacOS X
implementation will be later.
"""
tmpfile = NamedTemporaryFile()
command = "import gtk;w = gtk.Window();w.realize();style=w.get_style(); print style.font_desc.to_string();"
os.system('python -c "%s" >%s 2>/dev/null' % (command, tmpfile.name))
font = tmpfile.readline().strip()
normal_font = process_gtk_font_string(font)
small_font = copy.deepcopy(normal_font)
small_font[2] -= 1
large_font = copy.deepcopy(normal_font)
large_font[2] += 2
if not 'bold' in large_font[1]:
large_font[1].append('bold')
fixed_font = copy.deepcopy(normal_font)
fixed_font[0] = 'monospace'
return [small_font, normal_font, large_font, fixed_font]
def get_system_fonts():
"""
Returns list of four fonts, used in sK1 UI:
[small_font,normal_font,large_font,fixed_font]
Each font is a list like:
[font_family,font_style,font_size]
where:
font_family - string representation of font family
font_style - list of font styles like 'bold' and 'italic'
font_size - font size integer value
Currently Gtk binding is implemented. Win32 and MacOS X
implementation will be later.
"""
tmpfile = NamedTemporaryFile()
command = "import gtk;w = gtk.Window();w.realize();style=w.get_style(); print style.font_desc.to_string();"
os.system('python -c "%s" >%s 2>/dev/null' % (command, tmpfile.name))
font = tmpfile.readline().strip()
normal_font = process_gtk_font_string(font)
small_font = copy.deepcopy(normal_font)
small_font[2] -= 1
large_font = copy.deepcopy(normal_font)
large_font[2] += 2
if not 'bold' in large_font[1]:
large_font[1].append('bold')
fixed_font = copy.deepcopy(normal_font)
fixed_font[0] = 'monospace'
return [small_font, normal_font, large_font, fixed_font]
def get_gtk_fonts():
"""
Returns list of four fonts, used in UI:
[small_font,normal_font,large_font,fixed_font]
Each font is a list like:
[font_family,font_style,font_size]
where:
font_family - string representation of font family
font_style - list of font styles like 'bold' and 'italic'
font_size - font size integer value
"""
tmpfile = NamedTemporaryFile()
command = "import gi;from gi.repository import Gtk;print(Gtk.Settings.get_default().get_property('gtk-font-name'))"
os.system(sys.executable +' -c "%s" >%s 2>/dev/null' % (command, tmpfile.name))
font = tmpfile.readline().strip()
if not font:
font = 'Sans 10'
normal_font = process_gtk_font_string(font)
small_font = copy.deepcopy(normal_font)
small_font[2] -= 1
large_font = copy.deepcopy(normal_font)
large_font[2] += 2
if not 'bold' in large_font[1]:
large_font[1].append('bold')
fixed_font = copy.deepcopy(normal_font)
fixed_font[0] = 'monospace'
return [small_font, normal_font, large_font, fixed_font]
class TombOutputThread(QtCore.QThread):
line_received = QtCore.pyqtSignal(QtCore.QString)
error_received = QtCore.pyqtSignal(QtCore.QString)
progressed = QtCore.pyqtSignal(int) #value in percent
def __init__(self):
QtCore.QThread.__init__(self)
self.buffer = NamedTemporaryFile()
def run(self):
while True:
where = self.buffer.tell()
line = self.buffer.readline()
if not line:
time.sleep(1)
self.buffer.seek(where)
else:
#ansi color escapes messes this up, but it'ok anyway
self.line_received.emit(line)
self.parse_line(line)
def parse_line(self, line):
#This could be simplified, and s/search/match, if --no-color supported
#see #59
#TODO: this should be moved to tomblib.parse
parsed = parse_line(line)
if parsed and parsed['type'] == 'error':
self.error_received.emit(parsed.content)
class SDKServer(object):
def __init__(
self,
port=None, # type: Optional[int]
singleton=True, # type: bool
lazy=False, # type: bool
idle_timeout=None, # type: Optional[int]
log_file_name=None, # type: Optional[str]
executable=executable_path, # type: str
):
if log_file_name:
self._log_file = open(log_file_name, "w+b")
self.log_file_name = log_file_name
else:
self._log_file = NamedTemporaryFile("w+b")
self.log_file_name = self._log_file.name
self.executable = executable
command = [executable]
if port is not None:
command.extend(["--port", port])
if not singleton:
command.append("--no-singleton")
if lazy:
command.append("--lazy")
if idle_timeout is not None:
command.extend(["--idle-timeout", idle_timeout])
if sys.version_info < (3,) and sys.platform != "win32":
# python2 tends to hang if there are unclosed fds owned by child process
# close_fds is not supported by windows python2 so not using it there
sdk = Popen(command, stdout=self._log_file, stderr=STDOUT, close_fds=True)
else:
sdk = Popen(command, stdout=self._log_file, stderr=STDOUT)
self._sdk_process = None if singleton else sdk # leak the singleton process
self.port = self._read_port()
self.is_closed = False # explicit flag because python2 calls __del__ many times
logger.info("Started Universal SDK server at %s", self.port)
def _read_port(self):
while True:
self._log_file.seek(0)
first_line = self._log_file.readline()
if first_line:
return int(first_line)
else:
sleep(0.5)
def close(self):
if not self.is_closed:
self.is_closed = True
if self._sdk_process:
logger.info("Terminating Universal SDK server at %s", self.port)
self._sdk_process.terminate()
self._log_file.close()
def __repr__(self):
return "SDKServer(port={})".format(self.port)
def __del__(self):
self.close()
def wpteval(align, train_filenames, test_filename, gold_wa):
test_numbers = []
mosesf = NamedTemporaryFile('w+', encoding='utf-8')
with NamedTemporaryFile('w', encoding='utf-8') as outf1, \
NamedTemporaryFile('w', encoding='utf-8') as outf2:
with open(test_filename[0], 'r', encoding='utf-8') as f:
for i,line in enumerate(f):
m = RE_NUMBERED.match(line)
assert m, 'Test data file %s not numbered properly!' % \
test_filename[0]
test_numbers.append(m.group(1))
print(m.group(2).strip(), file=outf1)
with open(test_filename[1], 'r', encoding='utf-8') as f:
for i,line in enumerate(f):
m = RE_NUMBERED.match(line)
assert m, 'Test data file %s not numbered properly!' % \
test_filename[1]
assert test_numbers[i] == m.group(1)
print(m.group(2).strip(), file=outf2)
for filename1,filename2 in train_filenames:
with open(filename1, 'r', encoding='utf-8') as f1, \
open(filename2, 'r', encoding='utf-8') as f2:
while True:
line1 = f1.readline()
line2 = f2.readline()
assert (not line1) == (not line2), \
'Number of lines differs between %s and %s!' % (
filename1, filename2)
if (not line1) or (not line2): break
line1 = line1.strip()
line2 = line2.strip()
if line1 and line2:
print(line1, file=outf1)
print(line2, file=outf2)
outf1.flush()
outf2.flush()
align(outf1.name, outf2.name, mosesf.name)
with NamedTemporaryFile('w', encoding='utf-8') as outf:
for lineno in test_numbers:
for i,j in map(lambda s: s.split('-'), mosesf.readline().split()):
print('%s %d %d' % (lineno, int(i)+1, int(j)+1), file=outf)
outf.flush()
subprocess.call(
['perl', '3rdparty/wa_check_align.pl', outf.name])
subprocess.call(
['perl', '3rdparty/wa_eval_align.pl', gold_wa, outf.name])
mosesf.close()
def test_utils_redirect_output():
"""Test redirect output context manager."""
temp_file = NamedTemporaryFile(mode='w+', delete=False)
with ipa_utils.redirect_output(temp_file):
print('Test message to file!')
with open(temp_file.name) as temp_file:
assert temp_file.readline() == 'Test message to file!\n'
with ipa_utils.ignored(OSError):
os.remove(temp_file.name)
def import_gtk_colors(self):
"""
Imports system gtk color scheme using pygtk binding.
"""
colors={}
tmpfile=NamedTemporaryFile()
command="import gtk;w = gtk.Window();w.realize();style=w.get_style();"
command+="print style.base[gtk.STATE_NORMAL].to_string(),"+ \
" style.base[gtk.STATE_ACTIVE].to_string(),"+ \
" style.base[gtk.STATE_PRELIGHT].to_string(),"+ \
" style.base[gtk.STATE_SELECTED].to_string(),"+ \
" style.base[gtk.STATE_INSENSITIVE].to_string();"
command+="print style.text[gtk.STATE_NORMAL].to_string(),"+ \
" style.text[gtk.STATE_ACTIVE].to_string(),"+ \
" style.text[gtk.STATE_PRELIGHT].to_string(),"+ \
" style.text[gtk.STATE_SELECTED].to_string(),"+ \
" style.text[gtk.STATE_INSENSITIVE].to_string();"
command+="print style.fg[gtk.STATE_NORMAL].to_string(),"+ \
" style.fg[gtk.STATE_ACTIVE].to_string(),"+ \
" style.fg[gtk.STATE_PRELIGHT].to_string(),"+ \
" style.fg[gtk.STATE_SELECTED].to_string(),"+ \
" style.fg[gtk.STATE_INSENSITIVE].to_string();"
command+="print style.bg[gtk.STATE_NORMAL].to_string(),"+ \
" style.bg[gtk.STATE_ACTIVE].to_string(),"+ \
" style.bg[gtk.STATE_PRELIGHT].to_string(),"+ \
" style.bg[gtk.STATE_SELECTED].to_string(),"+ \
" style.bg[gtk.STATE_INSENSITIVE].to_string();"
os.system('python -c "%s" >%s 2>/dev/null'%(command, tmpfile.name))
for type in ["base","text","fg","bg"]:
line=tmpfile.readline().strip().split()
colors[type+' normal']=gtk_to_tk_color(line[0])
colors[type+' active']=gtk_to_tk_color(line[1])
colors[type+' prelight']=gtk_to_tk_color(line[2])
colors[type+' selected']=gtk_to_tk_color(line[3])
colors[type+' insensitive']=gtk_to_tk_color(line[4])
tmpfile.close()
self.map_gtk_colors(colors)
def import_gtk_colors(self):
"""
Imports system gtk color scheme using pygtk binding.
"""
colors = {}
tmpfile = NamedTemporaryFile()
command = "import gtk;w = gtk.Window();w.realize();style=w.get_style();"
command += "print style.base[gtk.STATE_NORMAL].to_string()," + \
" style.base[gtk.STATE_ACTIVE].to_string()," + \
" style.base[gtk.STATE_PRELIGHT].to_string()," + \
" style.base[gtk.STATE_SELECTED].to_string()," + \
" style.base[gtk.STATE_INSENSITIVE].to_string();"
command += "print style.text[gtk.STATE_NORMAL].to_string()," + \
" style.text[gtk.STATE_ACTIVE].to_string()," + \
" style.text[gtk.STATE_PRELIGHT].to_string()," + \
" style.text[gtk.STATE_SELECTED].to_string()," + \
" style.text[gtk.STATE_INSENSITIVE].to_string();"
command += "print style.fg[gtk.STATE_NORMAL].to_string()," + \
" style.fg[gtk.STATE_ACTIVE].to_string()," + \
" style.fg[gtk.STATE_PRELIGHT].to_string()," + \
" style.fg[gtk.STATE_SELECTED].to_string()," + \
" style.fg[gtk.STATE_INSENSITIVE].to_string();"
command += "print style.bg[gtk.STATE_NORMAL].to_string()," + \
" style.bg[gtk.STATE_ACTIVE].to_string()," + \
" style.bg[gtk.STATE_PRELIGHT].to_string()," + \
" style.bg[gtk.STATE_SELECTED].to_string()," + \
" style.bg[gtk.STATE_INSENSITIVE].to_string();"
os.system('python -c "%s" >%s 2>/dev/null' % (command, tmpfile.name))
for type in ["base", "text", "fg", "bg"]:
line = tmpfile.readline().strip().split()
colors[type + ' normal'] = gtk_to_tk_color(line[0])
colors[type + ' active'] = gtk_to_tk_color(line[1])
colors[type + ' prelight'] = gtk_to_tk_color(line[2])
colors[type + ' selected'] = gtk_to_tk_color(line[3])
colors[type + ' insensitive'] = gtk_to_tk_color(line[4])
tmpfile.close()
self.map_gtk_colors(colors)
def align_to_genome(basecalls, genome_filename, graphmap_path):
## align to genome
read_fp = NamedTemporaryFile(delete=False, suffix='.fasta')
read_fp.write(">" + ''.join(basecalls[:5]) + '\n' + ''.join(basecalls) +
'\n')
read_fp.close()
out_fp = NamedTemporaryFile(delete=False)
try:
# suppress output from graphmap with devnull sink
with open(os.devnull, 'w') as FNULL:
exitStatus = call([
graphmap_path, 'align', '-r', genome_filename, '-d',
read_fp.name, '-o', out_fp.name, '-L', 'm5'
],
stdout=FNULL,
stderr=STDOUT)
alignment = dict(zip(GRAPHMAP_FIELDS, out_fp.readline().split()))
out_fp.close()
except:
raise OSError, ('Problem running/parsing graphmap. Ensure ' +
'you have a compatible version installed.')
## flip read and genome to match raw signal if neg strand mapped
if len(alignment) != len(GRAPHMAP_FIELDS):
raise NotImplementedError, ('Graphmap did not produce alignment.')
if alignment['tStrand'] != '+':
raise NotImplementedError, (
'Graphmap indicates negative strand reference mapping.')
if alignment['qStrand'] == "+":
alignVals = zip(alignment['qAlignedSeq'], alignment['tAlignedSeq'])
else:
alignVals = zip(rev_comp(alignment['qAlignedSeq']),
rev_comp(alignment['tAlignedSeq']))
return alignVals, genomeLoc(int(alignment['tStart']), alignment['qStrand'],
alignment['tName'])
class ControlBase(metaclass=ABCMeta):
def __init__(self):
super().__init__()
self.rows = None
self.can_generate = True
self._temp_file = NamedTemporaryFile('r+', delete=False)
self.list_is_unique = True
def __del__(self):
import os
if not self._temp_file.closed:
self._temp_file.close()
os.unlink(self._temp_file.name)
def init_list(self):
self.rows = ASList(unique=self.list_is_unique)
@property
@abstractmethod
def type_name(self):
""" Must return the type name as is in SQL (e.g: VARCHAR(30) NOT NOLL...) """
pass
@abstractmethod
def gen(self):
""" Must generate the random data. If can_generate is set true then gen must do nothing. """
pass
def dump_line(self):
""" Get one item from the temporary file. If serialize() has not called before then the file will be empty """
return self._temp_file.readline().rstrip()
def serialize(self):
""" Save the data in a temporary file, one per line.
The file will be removed when the instance of this class get collected by the garbage collector
"""
self._temp_file.writelines([f"{str(item)}\n" for item in self.rows])
self._temp_file.flush()
self._temp_file.seek(0) # reset position for when dump_line be called
class FileStore(object):
def __init__(self, proxy, processId, mode= 'r'):
'''
Gives r+w access to file on static instance via local tempfile.NamedTemproraryFile
'''
self.proxy= proxy
self.processId= processId
self.mode= mode
self.tmpFile= NamedTemporaryFile(mode= 'r+', prefix= self.processId, delete= True)
if 'r' in mode:
self.__get__()
def __get__(self):
'''
Get contents of static instance file and save to local temp file
'''
data= self.proxy.getFileContents(self.processId)
self.tmpFile.write(data.tostring())
self.tmpFile.seek(0)
def __post__(self):
'''
Posts contents of local temp file to static instance file
'''
self.tmpFile.seek(0)
data= self.tmpFile.read()
self.proxy.setFileContents(self.processId, data)
self.tmpFile.seek(0)
def getName(self):
return self.processId
def getLocalName(self):
return self.tmpFile.name
def write(self, data):
'''
Writes data to local tempfile
'''
if 'w' not in self.mode:
raise Exception('file open for read only')
self.tmpFile.write(dumps(data))
def read(self, size= -1):
'''
Reads data from local tempfile. See file read() for more details.
'''
if 'r' not in self.mode:
raise Exception('file open for write only')
return loads(self.tmpFile.read(size))
def readlines(self):
'''
Reads lines from local tempfile. See file readlines() for more detals.
'''
if 'r' not in self.mode:
raise Exception('file open for write only')
return loads(self.tmpFile.readlines())
def readline(self):
'''
Reads line from local tempfile. See file readline() for more details.
'''
if 'r' not in self.mode:
raise Exception('file open for write only')
return loads(self.tmpFile.readline())
def close(self, delete= False):
'''
Saves the contents of the local tempfile and then closes/destroys the local tempfile. See self.__post__() and python tempfile for more details.
'''
if 'w' in self.mode:
self.__post__()
elif 'r' in self.mode:
# if delete requested -- remove file form static instance
if delete:
self.proxy.deleteFile(self.processId)
self.tmpFile.close()