예제 #1
0
		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)
예제 #2
0
		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)
예제 #3
0
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
예제 #4
0
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
예제 #5
0
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