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 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
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 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
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 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 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 _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 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 _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)
# 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 _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].*=.*'
return (pattern, processes)
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 _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)
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)
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].*=.*'
return (pattern, processes)
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, ())
async def __call__(self, url: str) -> None:
if self.arguments is None:
await logging.info(f'Launching {url!r} with default program')
await open_with_default_application(url)
else:
arguments = list(self.subbed_arguments(url))
startupinfo: Optional[STARTUPINFO]
if WINDOWS:
startupinfo = STARTUPINFO()
startupinfo.dwFlags = STARTF_USESHOWWINDOW
else:
startupinfo = None
await logging.info(
f'Launching subprocess with arguments {arguments}'
)
await run_subprocess(
args=arguments,
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.stdout)
self._check = GLib.timeout_add_seconds(1, self._cb_check_alive)
else:
cmdline = self.commandline
if self.iopriority != 0:
cmdline = [ "ionice", "-c", "%s" % self.iopriority ] + cmdline
if self.priority != 0:
# I just really do hope that there is no distro w/out nice command
cmdline = [ "nice", "-n", "%s" % self.priority ] + cmdline
print cmdline
if HAS_SUBPROCESS:
# New Gio
flags = Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE
self._proc = Gio.Subprocess.new(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 :(
self._proc = Popen(cmdline, 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 start_local(arch='x86', path=None):
'''start the wdbg subprocess, and return its listened port'''
path = path or search_wdbg(arch)
if not path:
return None
from subprocess import STARTUPINFO, SW_HIDE, PIPE
from subprocess import CREATE_NEW_CONSOLE, STARTF_USESHOWWINDOW
from subprocess import SubprocessError, Popen
si = STARTUPINFO()
si.dwFlags = STARTF_USESHOWWINDOW
si.wShowWindow = SW_HIDE
try:
return Popen([path, '-D', '-a', '127.0.0.1'],
bufsize=0,
startupinfo=si,
stdin=PIPE,
creationflags=CREATE_NEW_CONSOLE,
stdout=PIPE)
except SubprocessError:
return None
from bs4 import BeautifulSoup as bs
from datetime import datetime
from subprocess import Popen, STARTUPINFO
'''Path for the file to be written'''
FILE_PATH = 'E:\\Documents\\promocoes.txt'
BACKUP_FILE_PATH = 'E:\Documents\\promocoes_backup.txt'
'''Start up options for process
wShowWindow = 0 -> hidden'''
start_info = STARTUPINFO()
start_info.dwFlags = 1
start_info.wShowWindow = 1
'''current time'''
time = datetime.now()
def get_html_cloudfare(link):
scraper = cfscrape.create_scraper()
return scraper.get(link).content
def get_title(soup):
return soup.title.encode('utf-8')
from subprocess import PIPE
from .logging import Logger
__all__ = ('check_output', )
_l = Logger.from_module(__name__)
if sys.platform == 'win32':
import ctypes
from subprocess import STARTUPINFO
from subprocess import STARTF_USESHOWWINDOW
from subprocess import SW_HIDE
startup_info = STARTUPINFO()
startup_info.dwFlags = STARTF_USESHOWWINDOW | SW_HIDE
def _check_output(args,
shell=False,
universal_newlines=False,
timeout=None):
"""Conveniently read a process's output on Windows.
Supresses the console window and decodes the binary stream using the
console's codepage.
"""
# universal_newlines causes the output to be interpreted as `locale.getpreferredencoding()`,
# which doesn't work at times because console (OEM?) applications usually use a different
# encoding instead. For example, 850 for Western Europe, 437 for English and 936 for Chinese.
proc = Popen(args,
stdout=PIPE,
def _get_startupinfo(self):
from subprocess import STARTF_USESHOWWINDOW, SW_HIDE, STARTUPINFO
result = STARTUPINFO()
result.dwFlags = STARTF_USESHOWWINDOW
result.wShowWindow = SW_HIDE
return result
'check_output',
)
_l = Logger.from_module(__name__)
if sys.platform == 'win32':
import ctypes
from subprocess import STARTUPINFO
from subprocess import STARTF_USESHOWWINDOW
from subprocess import SW_HIDE
startup_info = STARTUPINFO()
startup_info.dwFlags = STARTF_USESHOWWINDOW | SW_HIDE
def _check_output(args, shell=False, universal_newlines=False, timeout=None):
"""Conveniently read a process's output on Windows.
Supresses the console window and decodes the binary stream using the
console's codepage.
"""
# universal_newlines causes the output to be interpreted as `locale.getpreferredencoding()`,
# which doesn't work at times because console (OEM?) applications usually use a different
# encoding instead. For example, 850 for Western Europe, 437 for English and 936 for Chinese.
proc = Popen(args, stdout=PIPE, stderr=PIPE, shell=shell, universal_newlines=False,
startupinfo=startup_info)
data, err = proc.communicate(timeout=timeout)
