def doCalc():
utils.setCurThreadName("Py %s" % threading.currentThread().name)
try:
value = self.calcAndSet(attrib)
except KeyboardInterrupt:
# This is from some user code. We are probably exiting. Just proceed with None.
value = None
with lock:
if not afterJoinEvent.isSet():
return
if gotNewValueEvent.isSet():
return
if callback: callback(self, attrib, value)
def doCalc():
utils.setCurThreadName("Py %s" % threading.currentThread().name)
try:
value = self.calcAndSet(attrib)
except KeyboardInterrupt:
# This is from some user code. We are probably exiting. Just proceed with None.
value = None
with lock:
if not afterJoinEvent.isSet():
return
if gotNewValueEvent.isSet():
return
if callback: callback(self, attrib, value)
def main():
import sys, os
from pprint import pprint
# Early check for forked process.
if appinfo.args.forkExecProc:
# Only import utils now for this case.
# Otherwise, I want "--pyshell" to be without utils loaded.
import utils
utils.ExecingProcess.checkExec()
# Early check for "--pyshell".
# This is a simple debug shell where we don't load anything.
if appinfo.args.pyshell:
better_exchook.simple_debug_shell({}, {})
raise SystemExit
# Early check for "--pyexec".
# This is a simple Python execution where we don't load anything.
if appinfo.args.pyexec:
sourcecode = appinfo.args.pyexec[0]
exec(compile(sourcecode, "<pyexec>", "exec"))
raise SystemExit
import utils
import time
print "MusicPlayer", appinfo.version, "from", appinfo.buildTime, "git-ref", appinfo.gitRef[:
10], "on", appinfo.platform, "(%s)" % sys.platform
print "startup on", utils.formatDate(time.time())
utils.setCurThreadName("Python main")
try:
# Hack: Make the `__main__` module also accessible as `main`.
mainmod = sys.modules["__main__"]
sys.modules.setdefault("main", mainmod)
del mainmod
except Exception:
sys.excepthook(*sys.exc_info())
# doesn't matter, continue
# Import PyObjC here. This is because the first import of PyObjC *must* be
# in the main thread. Otherwise, the NSAutoreleasePool created automatically
# by PyObjC on the first import would be released at exit by the main thread
# which would crash (because it was created in a different thread).
# http://pyobjc.sourceforge.net/documentation/pyobjc-core/intro.html
objc, AppKit = None, None
try:
import objc
except Exception:
if sys.platform == "darwin":
print "Error while importing objc"
sys.excepthook(*sys.exc_info())
# Otherwise it doesn't matter.
try:
# Seems that the `objc` module is not enough. Without `AppKit`,
# I still get a lot of
# __NSAutoreleaseNoPool(): ... autoreleased with no pool in place - just leaking
# errors.
if objc:
import AppKit
except Exception:
# Print error in any case, also ImportError, because we would expect that this works.
print "Error while importing AppKit"
sys.excepthook(*sys.exc_info())
# Import core module here. This is mostly as an early error check.
try:
import musicplayer
except Exception:
print "Error while importing core module! This is fatal."
sys.excepthook(*sys.exc_info())
print "Environment:"
pprint(os.environ)
raise
# Import gui module here. Again, mostly as an early error check.
# If there is no gui, the module should still load and provide
# dummy functions where appropriate.
import gui
# Default quit handling.
# Note that this is executed after `threading._shutdown`, i.e. after
# all non-daemon threads have finished.
import atexit
atexit.register(gui.handleApplicationQuit)
# Import some core modules. They propagate themselves to other
# subsystems, like GUI.
# XXX: Maybe move all this to `State` module?
import State
import Preferences
import Search
import SongEdit
# This will overtake the main loop and raise SystemExit at its end,
# or never return.
# It also just might do nothing.
gui.main()
# If we continue here, we can setup our own main loop.
# We have no GUI. Continue with some simple console control handling.
import stdinconsole
handleApplicationInit()
# Note on quit behavior: Simply iterating state.updates
# and waiting for its end does not work because we would
# not interrupt on signals, e.g. KeyboardInterrupt.
# It is also not possible (in general) to catch
# signals from other threads, thus we have to do it here.
# time.sleep() is a good way to wait for signals.
# However, we use stdinconsole.readNextInput() because
# there is simply no way to have os.read() in another thread
# and to be able to interrupt that from here (the main thread).
# In other threads: thread.interrupt_main() does not work
# for time.sleep() (or at least it will not interrupt the sleep).
# os.kill(0, signal.SIGINT) works, though.
# To interrupt/stop all threads:
# signal.set_wakeup_fd(sys.stdin.fileno()) also does not really
# work to interrupt the stdin thread, probably because stdin is
# not non-blocking.
# Every thread must only wait on a OnRequestQueue which registers
# itself in its thread. We cancelAll() here already the main queue
# (state.updates) and in Module.stop(), we also cancel any custom
# queue.
while True:
try:
stdinconsole.readNextInput() # wait for KeyboardInterrupt
except BaseException, e:
State.state.updates.put((e, (), {}))
State.state.updates.cancelAll()
break
def main():
import sys, os
from pprint import pprint
# Early check for forked process.
if appinfo.args.forkExecProc:
# Only import utils now for this case.
# Otherwise, I want "--pyshell" to be without utils loaded.
import utils
utils.ExecingProcess.checkExec()
# Early check for "--pyshell".
# This is a simple debug shell where we don't load anything.
if appinfo.args.pyshell:
better_exchook.simple_debug_shell({}, {})
raise SystemExit
# Early check for "--pyexec".
# This is a simple Python execution where we don't load anything.
if appinfo.args.pyexec:
sourcecode = appinfo.args.pyexec[0]
exec(compile(sourcecode, "<pyexec>", "exec"))
raise SystemExit
import utils
import time
print "MusicPlayer", appinfo.version, "from", appinfo.buildTime, "git-ref", appinfo.gitRef[:10], "on", appinfo.platform, "(%s)" % sys.platform
print "startup on", utils.formatDate(time.time())
utils.setCurThreadName("Python main")
try:
# Hack: Make the `__main__` module also accessible as `main`.
mainmod = sys.modules["__main__"]
sys.modules.setdefault("main", mainmod)
del mainmod
except Exception:
sys.excepthook(*sys.exc_info())
# doesn't matter, continue
# Import PyObjC here. This is because the first import of PyObjC *must* be
# in the main thread. Otherwise, the NSAutoreleasePool created automatically
# by PyObjC on the first import would be released at exit by the main thread
# which would crash (because it was created in a different thread).
# http://pyobjc.sourceforge.net/documentation/pyobjc-core/intro.html
objc, AppKit = None, None
try:
import objc
except Exception:
if sys.platform == "darwin":
print "Error while importing objc"
sys.excepthook(*sys.exc_info())
# Otherwise it doesn't matter.
try:
# Seems that the `objc` module is not enough. Without `AppKit`,
# I still get a lot of
# __NSAutoreleaseNoPool(): ... autoreleased with no pool in place - just leaking
# errors.
if objc:
import AppKit
except Exception:
# Print error in any case, also ImportError, because we would expect that this works.
print "Error while importing AppKit"
sys.excepthook(*sys.exc_info())
# Import core module here. This is mostly as an early error check.
try:
import musicplayer
except Exception:
print "Error while importing core module! This is fatal."
sys.excepthook(*sys.exc_info())
print "Environment:"
pprint(os.environ)
raise
# Import gui module here. Again, mostly as an early error check.
# If there is no gui, the module should still load and provide
# dummy functions where appropriate.
import gui
# Default quit handling.
# Note that this is executed after `threading._shutdown`, i.e. after
# all non-daemon threads have finished.
import atexit
atexit.register(gui.handleApplicationQuit)
# Import some core modules. They propagate themselves to other
# subsystems, like GUI.
# XXX: Maybe move all this to `State` module?
import State
import Preferences
import Search
import SongEdit
# This will overtake the main loop and raise SystemExit at its end,
# or never return.
# It also just might do nothing.
gui.main()
# If we continue here, we can setup our own main loop.
# We have no GUI. Continue with some simple console control handling.
import stdinconsole
handleApplicationInit()
# Note on quit behavior: Simply iterating state.updates
# and waiting for its end does not work because we would
# not interrupt on signals, e.g. KeyboardInterrupt.
# It is also not possible (in general) to catch
# signals from other threads, thus we have to do it here.
# time.sleep() is a good way to wait for signals.
# However, we use stdinconsole.readNextInput() because
# there is simply no way to have os.read() in another thread
# and to be able to interrupt that from here (the main thread).
# In other threads: thread.interrupt_main() does not work
# for time.sleep() (or at least it will not interrupt the sleep).
# os.kill(0, signal.SIGINT) works, though.
# To interrupt/stop all threads:
# signal.set_wakeup_fd(sys.stdin.fileno()) also does not really
# work to interrupt the stdin thread, probably because stdin is
# not non-blocking.
# Every thread must only wait on a OnRequestQueue which registers
# itself in its thread. We cancelAll() here already the main queue
# (state.updates) and in Module.stop(), we also cancel any custom
# queue.
while True:
try: stdinconsole.readNextInput() # wait for KeyboardInterrupt
except BaseException, e:
State.state.updates.put((e, (), {}))
State.state.updates.cancelAll()
break
def main():
import utils
utils.ExecingProcess.checkExec()
import sys, time
print "MusicPlayer", appinfo.version, "from", appinfo.buildTime, "git-ref", appinfo.gitRef[:10], "on", appinfo.platform, "(%s)" % sys.platform
print "startup on", utils.formatDate(time.time())
utils.setCurThreadName("Python main")
try:
# Hack: Make the `__main__` module also accessible as `main`.
mainmod = sys.modules["__main__"]
sys.modules.setdefault("main", mainmod)
del mainmod
except Exception:
sys.excepthook(*sys.exc_info())
# doesn't matter, continue
# Import PyObjC here. This is because the first import of PyObjC *must* be
# in the main thread. Otherwise, the NSAutoreleasePool created automatically
# by PyObjC on the first import would be released at exit by the main thread
# which would crash (because it was created in a different thread).
# http://pyobjc.sourceforge.net/documentation/pyobjc-core/intro.html
objc, AppKit = None, None
try:
import objc
except Exception:
if sys.platform == "darwin":
print "Error while importing objc"
sys.excepthook(*sys.exc_info())
# Otherwise it doesn't matter.
try:
# Seems that the `objc` module is not enough. Without `AppKit`,
# I still get a lot of
# __NSAutoreleaseNoPool(): ... autoreleased with no pool in place - just leaking
# errors.
if objc:
import AppKit
except Exception:
# Print error in any case, also ImportError, because we would expect that this works.
print "Error while importing AppKit"
sys.excepthook(*sys.exc_info())
from State import state, modules
import stdinconsole
import gui
try:
# This will overtake the main loop and raise SystemExit at its end.
gui.main()
except SystemExit:
raise
for m in modules: m.start()
successStartup = True
# Note on quit behavior: Simply iterating state.updates
# and waiting for its end does not work because we would
# not interrupt on signals, e.g. KeyboardInterrupt.
# It is also not possible (in general) to catch
# signals from other threads, thus we have to do it here.
# time.sleep() is a good way to wait for signals.
# However, we use stdinconsole.readNextInput() because
# there is simply no way to have os.read() in another thread
# and to be able to interrupt that from here (the main thread).
# In other threads: thread.interrupt_main() does not work
# for time.sleep() (or at least it will not interrupt the sleep).
# os.kill(0, signal.SIGINT) works, though.
# To interrupt/stop all threads:
# signal.set_wakeup_fd(sys.stdin.fileno()) also does not really
# work to interrupt the stdin thread, probably because stdin is
# not non-blocking.
# Every thread must only wait on a OnRequestQueue which registers
# itself in its thread. We cancelAll() here already the main queue
# (state.updates) and in Module.stop(), we also cancel any custom
# queue.
while True:
try: stdinconsole.readNextInput() # wait for KeyboardInterrupt
except BaseException, e:
state.updates.put((e, (), {}))
state.updates.cancelAll()
break