def start(self):
os.environ["STNORESTART"] = "1" # see syncthing --help
os.environ["STNOUPGRADE"] = "1" # hopefully implemented later
try:
self._cancel = Gio.Cancellable()
if IS_WINDOWS:
# Windows
sinfo = STARTUPINFO()
sinfo.dwFlags = STARTF_USESHOWWINDOW
sinfo.wShowWindow = 0
self._proc = Popen(self.commandline,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=sinfo)
self._stdout = WinPopenReader(self._proc)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
elif HAS_SUBPROCESS:
# New Gio
flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE
self._proc = Gio.Subprocess.new(self.commandline, flags)
self._proc.wait_check_async(None, self._cb_finished)
self._stdout = self._proc.get_stdout_pipe()
else:
# Gio < 3.12 - Gio.Subprocess is missing :(
self._proc = Popen(self.commandline, stdout=PIPE)
self._stdout = Gio.UnixInputStream.new(
self._proc.stdout.fileno(), False)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
except Exception, e:
# Startup failed
self.emit("failed", e)
return
def run(self):
fmt = self.fmt
fromFilename = currentFilename
toFilename = os.path.splitext(fromFilename)[0] + "." + fmt
args = ["pandoc", fromFilename]
if fmt == "pdf":
args.extend(["--pdf-engine", "wkhtmltopdf"])
args.extend(["-o", toFilename])
try:
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
except:
startupinfo = None
process = Popen(args=args,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=startupinfo)
err = process.communicate()[1].decode()
code = process.returncode
wnd.statusBar().showMessage(("转换成功: " +
toFilename) if code == 0 else "转换失败: " +
err)
self.done.emit(True)
def call(self, command, cwd="", log=True):
_error = False
_std_out = ""
_std_err = ""
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
startupinfo.wShowWindow = SW_HIDE
_arguments = dict(
stdout=PIPE,
stderr=PIPE,
startupinfo=startupinfo,
)
if cwd != "":
_arguments.update({"cwd": cwd})
try:
_proc = Popen(command, **_arguments)
_std_out, _std_err = _proc.communicate()
_std_out = _std_out.decode('utf8', 'ignore')
_std_err = _std_err.decode('utf8', 'ignore')
except:
_error = True
if log:
print("--> %s" % (str(command), ))
print("--> %s" % (str(_std_out + _std_err), ))
return _error
def run(self):
cwd=abspath(getcwd())
try:
wx.CallAfter(self.start_button.Enable,False)
wx.CallAfter(self.stop_button.Enable,True)
wx.CallAfter(self.mainframe.status_panel.Clear)
wx.CallAfter(self.s_pane.Disable)
for element in self.elements: wx.CallAfter(element.Enable,False)
for field in self.fields: wx.CallAfter(field.Disable)
wx.CallAfter(self.checkbox.Disable)
chdir(self.cwd_path)
if system()=="Windows":
si=STARTUPINFO()
si.dwFlags|=1
si.wShowWindow=0
proc=Popen(self.cmd,shell=False,stdin=None,stdout=PIPE,\
stderr=STDOUT,bufsize=0,startupinfo=si)
else:
proc=Popen(self.cmd,shell=False,stdin=None,stdout=PIPE,\
stderr=STDOUT,bufsize=0)
cr=0
line_start=0
line_stop=0
while True:
if self.stop_flag:
if system()=="Linux": proc.send_signal(signal.SIGKILL)
else: proc.kill()
wx.CallAfter(self.mainframe.status_panel.Clear)
break
symbol=proc.stdout.read(1)
if not symbol: break
else:
symbol_code=ord(symbol)
if symbol_code!=0xd:
if cr==0xd and symbol_code!=0xa:
cr=symbol_code
wx.CallAfter(self.mainframe.status_panel.Remove,\
line_start,line_stop)
line_stop=line_start
if system()=="Windows" and cr==0xd\
and symbol_code==0xa:
line_stop+=1
wx.CallAfter(self.mainframe.status_panel.write,symbol)
line_stop+=1
if ord(symbol)==0xa: line_start=line_stop
else: cr=0xd
wx.CallAfter(self.mainframe.status_panel.Refresh)
proc.wait()
for field in self.fields:
wx.CallAfter(field.Clear)
wx.CallAfter(field.Enable)
for element in self.elements: wx.CallAfter(element.Enable,True)
wx.CallAfter(self.checkbox.Enable)
chdir(cwd)
wx.CallAfter(self.checkbox.SetValue,False)
wx.CallAfter(self.start_button.Enable,True)
wx.CallAfter(self.stop_button.Enable,False)
wx.CallAfter(self.s_pane.Enable)
wx.CallAfter(self.mainframe.RequestUserAttention)
except: chdir(cwd)
def start_local(arch='x86', path=None):
'''start the wdbg subprocess, and return its listened port'''
if not path:
path = search_wdbg(arch)
if not path:
return None
from subprocess import STARTUPINFO, Popen, SW_HIDE
from subprocess import CREATE_NEW_CONSOLE, STARTF_USESHOWWINDOW, PIPE
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
wdbg = Popen([path, '-D', '-a', '127.0.0.1'],
bufsize=0,
startupinfo=si,
stdin=PIPE,
creationflags=CREATE_NEW_CONSOLE,
stdout=PIPE)
import re
line = wdbg.stdout.readline().decode()
port = re.search(r'\d+', line)
if port:
return int(port.group(0))
def launch(self, e=None):
"""
Launch the shortcut bound to this key
e: tkinter Event object, never needed
"""
shellrun = os.path.join(SCRIPT_PATH, 'shellrun.exe')
if self.game:
link_path = os.path.join(LINKS_PATH, self.game + '.lnk')
if not os.path.isfile(link_path):
link_path = os.path.join(LINKS_PATH, self.game + '.url')
if not os.path.isfile(link_path):
self.parent.pop_error('Shortcut is of unknown format.')
if self.admin:
print('running as admin')
try:
elevator = os.path.join(SCRIPT_PATH, 'elevate.exe')
startupinfo = STARTUPINFO()
startupinfo.dwFlags = STARTF_USESHOWWINDOW
startupinfo.wShowWindow = SW_HIDE
cmdcall(f'"{elevator}" "{link_path}"',
startupinfo=startupinfo)
except Exception as e:
self.parent.pop_error(
f'Error launching the game as admin:\n{e}')
return
else:
try:
# Using the AutoHotkey-generated utility because it was easier for me
# TODO: make pure Python
cmdcall(f'"{shellrun}" "{link_path}"')
except Exception as e:
self.parent.pop_error(f'Error launching game:\n{e}')
sys.exit()
def check_binary_exists(program_path):
"""
Function that checks whether a binary exists.
:param pathlib.Path program_path: The full path to the binary to check.
:return: program output to be parsed
:rtype: bytes
"""
log.debug('testing program_path: {text}'.format(text=program_path))
try:
# Setup startupinfo options for check_output to avoid console popping up on windows
if is_win():
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
else:
startupinfo = None
run_log = check_output([str(program_path), '--help'],
stderr=STDOUT,
startupinfo=startupinfo)
except CalledProcessError as e:
run_log = e.output
except Exception:
trace_error_handler(log)
run_log = ''
log.debug('check_output returned: {text}'.format(text=run_log))
return run_log
def connect_intercept(self):
hostname = self.path.split(':')[0]
certpath = "%s\\%s.crt" % (self.certdir.rstrip('\\'), hostname)
with self.lock:
if not os.path.isfile(certpath):
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
cert_generate(self.cakey, self.certkey, certpath, hostname)
self.wfile.write("{} {} {}\r\n".format(
self.protocol_version, 200, 'Connection Established').encode())
self.end_headers()
try:
self.connection = ssl.wrap_socket(self.connection,
keyfile=self.certkey,
certfile=certpath,
server_side=True)
except Exception as e:
print(e)
self.rfile = self.connection.makefile("rb", self.rbufsize)
self.wfile = self.connection.makefile("wb", self.wbufsize)
conntype = self.headers.get('Proxy-Connection', '')
if self.protocol_version == "HTTP/1.1" and conntype.lower() != 'close':
self.close_connection = 0
else:
self.close_connection = 1
def run_shell_command(args, input):
# Hide console window on Windows.
import sys
if sys.platform == 'win32':
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW
spinfo = STARTUPINFO()
spinfo.dwFlags |= STARTF_USESHOWWINDOW
else:
spinfo = None
from subprocess import Popen, PIPE
try:
p = Popen(args,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=spinfo)
except:
return None, None, None
# Use communicate() to read stdout and stderr without blocking.
msout, mserr = p.communicate(input=input) # returns strings
status = p.wait()
return msout, mserr, status
def daemonize(options: Options,
status_file: str,
timeout: Optional[int] = None,
log_file: Optional[str] = None) -> int:
"""Create the daemon process via "dmypy daemon" and pass options via command line
When creating the daemon grandchild, we create it in a new console, which is
started hidden. We cannot use DETACHED_PROCESS since it will cause console windows
to pop up when starting. See
https://github.com/python/cpython/pull/4150#issuecomment-340215696
for more on why we can't have nice things.
It also pickles the options to be unpickled by mypy.
"""
command = [
sys.executable, '-m', 'mypy.dmypy', '--status-file', status_file,
'daemon'
]
pickeled_options = pickle.dumps(
(options.snapshot(), timeout, log_file))
command.append('--options-data="{}"'.format(
base64.b64encode(pickeled_options).decode()))
info = STARTUPINFO()
info.dwFlags = 0x1 # STARTF_USESHOWWINDOW aka use wShowWindow's value
info.wShowWindow = 0 # SW_HIDE aka make the window invisible
try:
subprocess.Popen(
command,
creationflags=0x10, # CREATE_NEW_CONSOLE
startupinfo=info)
return 0
except subprocess.CalledProcessError as e:
return e.returncode
async def async_disconnect_all(_self, disconnect_array, sw_close):
#
timeout = float(_self.config["SETTINGS"]["connecting_timeout"])
#
menu_box_spinner = QtWaitingSpinner(_self.menu_box, True, True,
Qt.ApplicationModal)
server_box_spinner = QtWaitingSpinner(_self.server_box, True, True,
Qt.ApplicationModal)
device_box_spinner = QtWaitingSpinner(_self.device_box, True, True,
Qt.ApplicationModal)
#
config.spinner_queue.start_spinner(
[menu_box_spinner, server_box_spinner, device_box_spinner])
_self.cancel_process.setParent(_self)
_self.cancel_process.show()
# Number of remaining devices
array_length = config.get_array_length(disconnect_array)
#
for srv_addr in disconnect_array:
for dev_bus in list(disconnect_array[srv_addr]):
index = config.usbip_array[srv_addr][dev_bus]["d_index"]
# Reducing the number of remaining devices
array_length -= 1
# Eliminating windows console during process execution
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
#
query = Popen("usbip.exe -d {0}".format(index),
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=startupinfo)
query.wait()
#
config.logging_result.append_text(
_self,
_("The {0} device from the {1} server has disconnected, {2} left"
).format(dev_bus, srv_addr, str(array_length)),
warn=True)
#
await sleep(timeout)
# Stopping all running processes and shutdown the program
if sw_close:
for queue in all_tasks(_self.main_loop):
queue.cancel()
with suppress(CancelledError):
await queue
_self.main_loop.stop()
#
config.spinner_queue.stop_spinner(
[menu_box_spinner, server_box_spinner, device_box_spinner])
_self.cancel_process.setParent(None)
async def convert_ardf(ardf_path, conv_path="ARDFtoHDF5.exe", pbar=None):
"""Turn an ARDF into a corresponding ARH5, returning the path.
Requires converter executable available from Asylum Research"""
ardf_path = trio.Path(ardf_path)
h5file_path = ardf_path.with_suffix(".h5")
if pbar is None:
pipe = None
else:
pbar.set_description_str("Converting " + ardf_path.name)
pipe = PIPE
async def reading_stdout():
stdout = bytearray()
async for bytes_ in proc.stdout:
stdout.extend(bytes_)
stdout = stdout.decode()
if "Failed" in stdout:
raise RuntimeError(stdout)
else:
print(stdout)
async def reading_stderr():
async for bytes_ in proc.stderr:
i = bytes_.rfind(
b"\x08") + 1 # first thing on right not a backspace
most_recent_numeric_output = bytes_[i:-1] # crop % sign
if most_recent_numeric_output:
pbar.update(
float(most_recent_numeric_output.decode()) - pbar.n)
try:
async with await trio.open_process(
[str(conv_path), str(ardf_path),
str(h5file_path)],
stderr=pipe,
stdout=pipe,
startupinfo=STARTUPINFO(dwFlags=STARTF_USESHOWWINDOW),
) as proc:
if pbar is not None:
async with trio.open_nursery() as nursery:
nursery.start_soon(reading_stdout)
nursery.start_soon(reading_stderr)
except FileNotFoundError:
raise FileNotFoundError(
"Please acquire ARDFtoHDF5.exe and place it in the application's root folder."
)
except:
with trio.CancelScope(shield=True):
await h5file_path.unlink(missing_ok=True)
raise
finally:
if pbar is not None:
pbar.close()
return h5file_path
def get_angles(location):
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
output, _ = Popen(
["python", "inverse_kinematics.py", str(location[0]), str(location[1]),
str(location[2])],
stdin=PIPE, stdout=PIPE, stderr=PIPE, startupinfo=startupinfo).communicate()
return str(output).split(" ")
def _spawn_windows(cmd, env):
from subprocess import STARTF_USESHOWWINDOW, STARTUPINFO
creationflags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
_popen(cmd, env=env, creationflags=creationflags,
startupinfo=startupinfo).communicate()
def movie_download(path, torrent_path):
print(colored('\n[-] STARTING DOWNLOAD', 'green', attrs=['bold']))
info = STARTUPINFO()
info.dwFlags = 1
info.wShowWindow = 0
Popen("torrent.exe", startupinfo=info)
qb = Client('http://127.0.0.1:8081/')
qb.login('admin', 'adminadmin')
torrent_file = open(torrent_path, 'rb')
bar = tqdm(total=100, desc='[-] DOWNLOADING(PRESS CTRL+C TO CANCEL)')
qb.download_from_file(torrent_file, savepath=path)
try:
while 1:
torrents = qb.torrents()
b = torrents[-1]['progress']
if b >= 1:
qb.delete_all()
Popen('taskkill /F /IM torrent.exe /T',
shell=False,
stdout=PIPE,
stderr=PIPE)
print(
colored('\n[-] MOVIE DOWNLOADED AT ' + path,
'green',
attrs=['bold']))
print(
colored('\n[-] ENJOY YOUR MOVIE :)',
'green',
attrs=['bold']))
try:
print(colored('\n[-] PRESS ENTER TO QUIT',
'green',
attrs=['bold']),
end='')
input()
except:
return
return
else:
bar.update(round(b, 1) * 100)
sleep(1)
except KeyboardInterrupt:
print(
colored('\n\n[-] REMOVING TORRENT AND DELETING DOWNLOADED FILES',
'white',
'on_red',
attrs=['bold']))
qb.delete_all_permanently()
sleep(2)
Popen('taskkill /F /IM torrent.exe /T',
shell=False,
stdout=PIPE,
stderr=PIPE)
except:
pass
def Popen(*args, show='normal', priority=2, **kwargs):
if os.name == 'nt':
if isinstance(show, str):
show = WINDOW_STATES[show]
if show != 1:
startupinfo = kwargs.get('startupinfo', STARTUPINFO())
startupinfo.dwFlags |= 1 #subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = show
kwargs['startupinfo'] = startupinfo
kwargs['creationflags'] = kwargs.get('creationflags',
0) | PROCESS_PRIORITIES[priority]
return Popen_original(*args, **kwargs)
def run_engine(slice_message: Slice, event_handler, child_started_handler=None, keep_alive_handler=None):
with open(engine_log_file, 'a+') as log_file:
print(datetime.now(), file=log_file, flush=True)
encoded_message = Slice.dumps(slice_message)
config = read_configuration()
print(dict(config), file=log_file, flush=True)
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as server_socket:
server_socket.bind(('127.0.0.1', 0))
server_socket.listen(5)
name = server_socket.getsockname()
extra_params = {}
if os.name == 'nt':
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW
info = STARTUPINFO()
info.dwFlags |= STARTF_USESHOWWINDOW
extra_params['startupinfo'] = info
cmd = ' '.join(['"' + config['curaengine'] + '"', 'connect', "%s:%s" % name, '-j',
'"' + fdmprinterfile + '"'])
print(cmd, file=log_file, flush=True)
child_process = Popen(cmd, stdout=log_file, stderr=log_file, **extra_params, shell=True)
if child_started_handler:
child_started_handler(child_process)
try:
print(child_process, file=log_file, flush=True)
print(child_process.poll(), file=log_file, flush=True)
(client_socket, address) = server_socket.accept()
client_socket.send(struct.pack("I", socket.htonl(_SIGNATURE)))
client_socket.send(struct.pack("!I", len(encoded_message)))
client_socket.send(struct.pack("!I", symbol_message_dict['cura.proto.Slice'].hash))
client_socket.send(encoded_message)
while 1:
process = client_socket.recv(4)
if len(process) == 4:
unpacked = struct.unpack('>I', process)[0]
if unpacked == 0:
if keep_alive_handler:
keep_alive_handler()
continue
if unpacked == _CLOSE_SOCKET:
print('_CLOSE_SOCKET')
return
if unpacked == _SIGNATURE:
size = struct.unpack('>I', client_socket.recv(4))[0]
type_id = struct.unpack('>I', client_socket.recv(4))[0]
type_def = hash_message_dict[type_id]
res3 = recvall(client_socket, size) if size else b''
event_handler(res3, type_def)
continue
break
else:
break
finally:
print(child_process.communicate(), file=log_file, flush=True)
def Enable(self) -> None:
if self.Token is None:
return
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= 1 # STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 7 # SW_SHOWMINNOACTIVE
self._listener = subprocess.Popen(
["python", "-m", "Listener", self.Token],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=self.BASE_PATH,
startupinfo=startupinfo)
def OnTick() -> None:
if self._listener is None:
return
if self._listener.poll() is not None:
# Since the lister has quit we can safely call read without blocking
# Only do this on stderr though cause that's where exceptions go
line = self._listener.stderr.read()
if len(line) > 0:
self.HandleStderr(
line.decode("utf8").replace("\\n", "\n")[:-2])
self.HandleChildQuit()
return
if GetPipeAvailableLen(self._listener.stdout) > 0:
line = self._listener.stdout.readline()
self.HandleStdout(
line.decode("utf8").replace("\\n", "\n")[:-2])
if GetPipeAvailableLen(self._listener.stderr) > 0:
line = self._listener.stderr.readline()
self.HandleStderr(
line.decode("utf8").replace("\\n", "\n")[:-2])
def OnQuit(caller: unrealsdk.UObject, function: unrealsdk.UFunction,
params: unrealsdk.FStruct) -> bool:
if self._listener is not None:
self._listener.kill()
return True
AsyncUtil.RunEveryTick(OnTick, "CrowdControl")
unrealsdk.RegisterHook(
"WillowGame.FrontendGFxMovie.ConfirmQuit_Clicked", "CrowdControl",
OnQuit)
for callback in Effects.ON_ENABLE:
callback()
def exec_cmd(cmd, path):
from subprocess import Popen, PIPE
if IS_WINDOWS:
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW, SW_HIDE
# Hide the console window
info = STARTUPINFO()
info.dwFlags |= STARTF_USESHOWWINDOW
info.wShowWindow = SW_HIDE
else:
info = None
process = Popen(cmd, stdout=PIPE, stdin=PIPE, stderr=PIPE, cwd=get_pathinfo(path)[1],
env=update_environ(), shell=IS_WINDOWS, startupinfo=info)
return process
def _pingAsync():
try:
if os.name == 'nt':
args = 'ping -n 1 -w 1000 '
# ќтвет от 178.20.235.151: число байт=32 врем¤=23мс TTL=58
pattern = '.*=.*=(\d+)[^\s].*=.*'
env = None
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
else:
args = 'ping -c 1 -n -q '
pattern = '[\d.]+/([\d.]+)(?:/[\d.]+){2}'
env = dict(LANG='C')
si = None
res = {}
processes = {}
# Ping all servers in parallel
for x in g_preDefinedHosts._hosts:
processes[x.name] = Popen(args + x.url.split(':')[0],
stdout=PIPE,
env=env,
startupinfo=si)
# Parse ping output
for x in g_preDefinedHosts._hosts:
proc = processes[x.name]
out, err = proc.communicate()
errCode = proc.wait()
if errCode != 0:
res[x.name] = 'E:' + str(errCode)
continue
found = re.search(pattern, out)
if not found:
res[x.name] = '?'
err('Ping regexp not found in %s' % out.replace('\n', '\\n'))
continue
res[x.name] = found.group(1)
global _pingResults
with _lockPing:
_pingResults = res #json.dumps(res)
#log('Async PING results: %s' % _pingResults)
finally:
global _thread
_thread = None
def _spawn_windows(cmd):
from subprocess import STARTUPINFO, STARTF_USESHOWWINDOW
creationflags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
Popen(cmd,
env=fix_env(),
close_fds=True,
shell=False,
creationflags=creationflags,
startupinfo=startupinfo).communicate()
def Popen_background(input_func):
# Prevents console from appearing on screen during Popen
startupinfo = None
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
startupinfo.wShowWindow = SW_HIDE
result = Popen(input_func,
stdout=PIPE,
stderr=PIPE,
startupinfo=startupinfo)
out, err = result.communicate()
return out, err
def start(self):
for x in self.env:
os.environ[x] = self.env[x]
try:
self._cancel = Gio.Cancellable()
if IS_WINDOWS:
# Windows
sinfo = STARTUPINFO()
sinfo.dwFlags = STARTF_USESHOWWINDOW
sinfo.wShowWindow = 0
cflags = nice_to_priority_class(self.priority)
self._proc = Popen(self.cmdline,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=sinfo,
creationflags=cflags)
self._stdout = WinPopenReader(self._proc.stdout)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
elif HAS_SUBPROCESS:
# New Gio
flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE
if self.priority == 0:
self._proc = Gio.Subprocess.new(self.cmdline, flags)
else:
# I just really do hope that there is no distro w/out nice command
self._proc = Gio.Subprocess.new(
["nice", "-n", "%s" % self.priority] + self.cmdline,
flags)
self._proc.wait_check_async(None, self._cb_finished)
self._stdout = self._proc.get_stdout_pipe()
else:
# Gio < 3.12 - Gio.Subprocess is missing :(
if self.priority == 0:
self._proc = Popen(self.cmdline, stdout=PIPE)
else:
# still hoping
self._proc = Popen(
["nice", "-n", "%s" % self.priority], stdout=PIPE)
self._stdout = Gio.UnixInputStream.new(
self._proc.stdout.fileno(), False)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
except Exception as e:
# Startup failed
self.emit("failed", e)
return
self._lines = deque([], DaemonProcess.SCROLLBACK_SIZE)
self._buffer = ""
self._stdout.read_bytes_async(256, 0, self._cancel, self._cb_read, ())
def process_image(imagename,resultname,params="--edge-thresh 10 --peak-thresh 5"):
""" Process an image and save the results in a file. """
if imagename[-3:] != 'pgm':
# create a pgm file
im = Image.open(imagename).convert('L')
im.save('tmp.pgm')
imagename = 'tmp.pgm'
# run the sift.exe file
cmmd = str("sift "+imagename+" --output="+resultname+" "+params)
if os.name == 'nt': # only on windows
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
p = Popen(cmmd, stdout = PIPE, startupinfo=startupinfo) # run sift.exe in subprocess (no separate window opens)
p.wait() # wait until subprocess finished
def popen(self):
if debug:
print("popen cmd: %s" % self.args)
if self.dry_run:
return
startupinfo = None
if self.hidden:
from subprocess import STARTUPINFO, _winapi
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= _winapi.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = _winapi.SW_HIDE
subprocess.Popen(self.args[0] if len(self.args) == 1 else self.args,
cwd=self.cwd, startupinfo=startupinfo)
def _spawn_windows(cmd, env):
from subprocess import (
CREATE_NEW_PROCESS_GROUP,
STARTF_USESHOWWINDOW,
STARTUPINFO,
)
# https://stackoverflow.com/a/7006424
# https://bugs.python.org/issue41619
creationflags = CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
startupinfo = STARTUPINFO()
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
_popen(cmd, env=env, creationflags=creationflags, startupinfo=startupinfo)
def start(self):
os.environ["STNORESTART"] = "1" # see syncthing --help
os.environ["STNOUPGRADE"] = "1" # hopefully implemented later
if self.max_cpus > 0:
os.environ["GOMAXPROCS"] = str(self.max_cpus)
try:
self._cancel = Gio.Cancellable()
if IS_WINDOWS:
# Windows
sinfo = STARTUPINFO()
sinfo.dwFlags = STARTF_USESHOWWINDOW
sinfo.wShowWindow = 0
cflags = nice_to_priority_class(self.priority)
self._proc = Popen(self.commandline,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE,
startupinfo=sinfo,
creationflags=cflags)
self._stdout = WinPopenReader(self._proc)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
elif HAS_SUBPROCESS:
# New Gio
flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE
if self.priority == 0:
self._proc = Gio.Subprocess.new(self.commandline, flags)
else:
# I just really do hope that there is no distro w/out nice command
self._proc = Gio.Subprocess.new(
["nice", "-%s" % self.priority] + self.commandline,
flags)
self._proc.wait_check_async(None, self._cb_finished)
self._stdout = self._proc.get_stdout_pipe()
else:
# Gio < 3.12 - Gio.Subprocess is missing :(
if self.priority == 0:
self._proc = Popen(self.commandline, stdout=PIPE)
else:
# still hoping
self._proc = Popen(["nice", "-%s" % self.priority],
stdout=PIPE)
self._stdout = Gio.UnixInputStream.new(
self._proc.stdout.fileno(), False)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
except Exception, e:
# Startup failed
self.emit("failed", e)
return
def _execute_child(self, args, executable, preexec_fn, close_fds, cwd,
env, universal_newlines, startupinfo, creationflags,
shell, p2cread, p2cwrite, c2pread, c2pwrite,
errread, errwrite):
"""Execute program (MS Windows version)"""
if not isinstance(args, types.StringTypes):
args = list2cmdline(args)
# Process startup details
if startupinfo is None:
startupinfo = STARTUPINFO()
if None not in (p2cread, c2pwrite, errwrite):
startupinfo.dwFlags |= STARTF_USESTDHANDLES
startupinfo.hStdInput = p2cread
startupinfo.hStdOutput = c2pwrite
startupinfo.hStdError = errwrite
if shell:
startupinfo.dwFlags |= STARTF_USESHOWWINDOW
startupinfo.wShowWindow = SW_HIDE
comspec = os.environ.get("COMSPEC", "cmd.exe")
args = comspec + " /c " + args
if (GetVersion() >= 0x80000000L
or os.path.basename(comspec).lower() == "command.com"):
# Win9x, or using command.com on NT. We need to
# use the w9xpopen intermediate program. For more
# information, see KB Q150956
# (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
w9xpopen = self._find_w9xpopen()
args = '"%s" %s' % (w9xpopen, args)
# Not passing CREATE_NEW_CONSOLE has been known to
# cause random failures on win9x. Specifically a
# dialog: "Your program accessed mem currently in
# use at xxx" and a hopeful warning about the
# stability of your system. Cost is Ctrl+C wont
# kill children.
creationflags |= CREATE_NEW_CONSOLE
# We create a new job for this process, so that we can kill
# the process and any sub-processes
self._job = winprocess.CreateJobObject()
creationflags |= winprocess.CREATE_SUSPENDED
# Vista will launch Komodo in a job object itself, so we need
# to specify that the created process is not part of the Komodo
# job object, but instead specify that it will be using a
# separate breakaway job object, bug 83001.
creationflags |= winprocess.CREATE_BREAKAWAY_FROM_JOB
def _pingAsyncWindows(self):
args = 'ping -n 1 -w 1000 '
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
# Ping all servers in parallel
processes = dict()
for x in self.hosts:
processes[x['name']] = Popen(args + x['url'].split(':')[0], stdout=PIPE, startupinfo=si)
# ќтвет от 178.20.235.151: число байт=32 врем¤=23мс TTL=58
#pattern = '.*=.*=(\d+)[^\s].*=.*' #original pattern, working with russian, not with others
pattern = '.*=.*=(\d+).*[^\s].*=.*' #fixed pattern, need testing but should work with every language
return (pattern, processes)
def _open_subprocess(self, args, passphrase=False):
# Internal method: open a pipe to a GPG subprocess and return
# the file objects for communicating with it.
cmd = self.make_args(args, passphrase)
if self.verbose:
pcmd = ' '.join(cmd)
print(pcmd)
logger.debug("%s", cmd)
if not STARTUPINFO:
si = None
else:
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
return Popen(cmd, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE,
startupinfo=si)
