def main():
if getattr(sys, "frozen", False) and sys.platform in ['win32','cygwin','win64']:
# and now redirect all default streams to DummyStream:
sys.stdout = DummyStream()
sys.stderr = DummyStream()
sys.stdin = DummyStream()
sys.__stdout__ = DummyStream()
sys.__stderr__ = DummyStream()
sys.__stdin__ = DummyStream()
# Get application path
app_path = getAppPath()
if sys.platform == 'darwin' and hasattr(sys, 'frozen'):
resources_path = os.path.normpath(os.path.abspath(os.path.join(app_path, "..", "Resources")))
else:
resources_path = os.path.normpath(os.path.abspath(os.path.join(app_path, "Resources")))
# Application setup
app = QSingleApplication(sys.argv)
app.setOrganizationName('Sumokoin')
app.setOrganizationDomain('www.sumokoin.org')
app.setApplicationName(APP_NAME)
app.setProperty("AppPath", app_path)
app.setProperty("ResPath", resources_path)
if sys.platform == 'darwin':
app.setAttribute(QtCore.Qt.AA_DontShowIconsInMenus)
if not _check_file_integrity(app):
QMessageBox.critical(None, "Application Fatal Error", """<b>File integrity check failed!</b>
<br><br>This could be a result of unknown (maybe, malicious) action<br> to wallet code files.""")
app.quit()
else:
hub = Hub(app=app)
ui = MainWebUI(app=app, hub=hub, debug=False)
hub.setUI(ui)
app.singleStart(ui)
sys.exit(app.exec_())
python类__stdin__()的实例源码
def disable():
sys.stdin.flush()
sys.stdout.flush()
sys.stderr.flush()
sys.stdin = sys.__stdin__
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
# PY3 # def enable(*, stdin=Ellipsis, stdout=Ellipsis, stderr=Ellipsis):
def _import(name, filename=None):
"""
Run the given callable in a 'sandboxed' environment.
Currently, this includes saving and restoring the contents of
sys and __builtins__; and suppressing stdin, stdout, and stderr.
"""
# Note that we just do a shallow copy of sys. In particular,
# any changes made to sys.modules will be kept. But we do
# explicitly store sys.path.
old_sys = sys.__dict__.copy()
old_sys_path = sys.path[:]
old_builtins = __builtin__.__dict__.copy()
# Add the current directory to sys.path, in case they're trying to
# import a module by name that resides in the current directory.
# But add it to the end -- otherwise, the explicit directory added
# in get_value_from_filename might get overwritten
sys.path.append('')
# Suppress input and output. (These get restored when we restore
# sys to old_sys).
sys.stdin = sys.stdout = sys.stderr = _dev_null
sys.__stdin__ = sys.__stdout__ = sys.__stderr__ = _dev_null
# Remove any command-line arguments
sys.argv = ['(imported)']
try:
try:
if filename is None:
return __import__(name)
else:
# For importing scripts:
return imp.load_source(name, filename)
except KeyboardInterrupt: raise
except:
exc_typ, exc_val, exc_tb = sys.exc_info()
if exc_val is None:
estr = '%s' % (exc_typ,)
else:
estr = '%s: %s' % (exc_typ.__name__, exc_val)
if exc_tb.tb_next is not None:
estr += ' (line %d)' % (exc_tb.tb_next.tb_lineno,)
raise ImportError(estr)
finally:
# Restore the important values that we saved.
__builtin__.__dict__.clear()
__builtin__.__dict__.update(old_builtins)
sys.__dict__.clear()
sys.__dict__.update(old_sys)
sys.path = old_sys_path
def step(context, args):
from StringIO import StringIO
import sys
context.stdin = StringIO()
context.stdout = StringIO()
context.stderr = StringIO()
try:
sys.stdin = context.stdin
sys.stdout = context.stdout
sys.stderr = context.stderr
if [s for s in context.scenario.steps if 'should be prompted' in s.name]:
# Fake this out for scenarios that expect a prompt
sys.stdin.write("yes\n")
else:
# Scenarios that don't expect a prompt but get one will fail
sys.stdin.write("no\n")
sys.stdin.seek(0)
if 'cli_config' in context and context.cli_config:
standard_cli(args=args.split(), config=context.cli_config)
else:
# Set env vars for username/password so that we don't need
# to pollute the features files with them.
os.environ['CHROMA_USERNAME'] = 'admin'
os.environ['CHROMA_PASSWORD'] = 'lustre'
standard_cli(args.split())
except SystemExit, e:
context.stdout.seek(0)
context.stderr.seek(0)
forced = any([a in ['--force', '-f'] for a in args.split()])
if e.code != 0 and not context.cli_failure_expected:
fail("code: %d stdout: %s stderr: %s" %
(e.code, context.stdout.readlines(), context.stderr.readlines()))
elif e.code == 0 and context.cli_failure_expected and not forced:
fail("Failure expected but didn't happen!\nstdout: %s, stderr: %s" %
(context.stdout.readlines(), context.stderr.readlines()))
except Exception, e:
context.stdout.seek(0)
context.stderr.seek(0)
from traceback import format_exc
fail("%s\nstdout:\n%s\nstderr:\n%s" %
(format_exc(),
"".join(context.stdout.readlines()),
"".join(context.stderr.readlines())))
sys.stdin = sys.__stdin__
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
def cbreak(self):
"""
Allow each keystroke to be read immediately after it is pressed.
This is a context manager for :func:`tty.setcbreak`.
This context manager activates 'rare' mode, the opposite of 'cooked'
mode: On entry, :func:`tty.setcbreak` mode is activated disabling
line-buffering of keyboard input and turning off automatic echo of
input as output.
.. note:: You must explicitly print any user input you would like
displayed. If you provide any kind of editing, you must handle
backspace and other line-editing control functions in this mode
as well!
**Normally**, characters received from the keyboard cannot be read
by Python until the *Return* key is pressed. Also known as *cooked* or
*canonical input* mode, it allows the tty driver to provide
line-editing before shuttling the input to your program and is the
(implicit) default terminal mode set by most unix shells before
executing programs.
Technically, this context manager sets the :mod:`termios` attributes
of the terminal attached to :obj:`sys.__stdin__`.
.. note:: :func:`tty.setcbreak` sets ``VMIN = 1`` and ``VTIME = 0``,
see http://www.unixwiz.net/techtips/termios-vmin-vtime.html
"""
if HAS_TTY and self._keyboard_fd is not None:
# Save current terminal mode:
save_mode = termios.tcgetattr(self._keyboard_fd)
save_line_buffered = self._line_buffered
tty.setcbreak(self._keyboard_fd, termios.TCSANOW)
try:
self._line_buffered = False
yield
finally:
# Restore prior mode:
termios.tcsetattr(self._keyboard_fd,
termios.TCSAFLUSH,
save_mode)
self._line_buffered = save_line_buffered
else:
yield
