def run_mainloop_with(self, target): """Start the OS's main loop to process asyncronous BLE events and then run the specified target function in a background thread. Target function should be a function that takes no parameters and optionally return an integer response code. When the target function stops executing or returns with value then the main loop will be stopped and the program will exit with the returned code. Note that an OS main loop is required to process asyncronous BLE events and this function is provided as a convenience for writing simple tools and scripts that don't need to be full-blown GUI applications. If you are writing a GUI application that has a main loop (a GTK glib main loop on Linux, or a Cocoa main loop on OSX) then you don't need to call this function. """ # Create background thread to run user code. self._user_thread = threading.Thread(target=self._user_thread_main, args=(target,)) self._user_thread.daemon = True self._user_thread.start() # Run main loop. This call will never return! try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: AppHelper.stopEventLoop() sys.exit(0)
def start(self): try: logger.info('Starting eventloop') AppHelper.runConsoleEventLoop() except KeyboardInterrupt: self.outputter.out_signal() logger.exception("KeyboardInterrrupt, shutting down")
def main(): nc = NSWorkspace.sharedWorkspace().notificationCenter() observer = Observer.new() nc.addObserver_selector_name_object_( observer, "handle:", NSWorkspaceDidActivateApplicationNotification, None) AppHelper.runConsoleEventLoop(installInterrupt=True)
def run(self) -> None: NSApplication.sharedApplication() self.delegate = AppDelegate.alloc().init() self.delegate.handler = Handler() NSApp().setDelegate_(self.delegate) self.workspace = NSWorkspace.sharedWorkspace() nc = self.workspace.notificationCenter() nc.addObserver_selector_name_object_( self.delegate, 'applicationActivated:', 'NSWorkspaceDidActivateApplicationNotification', None, ) nc.addObserver_selector_name_object_( self.delegate, 'screenSleep:', 'NSWorkspaceScreensDidSleepNotification', None, ) NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_( self.polling_time, self.delegate, 'writeActiveApp:', None, True) AppHelper.runConsoleEventLoop(maxTimeout=1)
def eol_flush(self): if self.queue: self.do_play() if self.playing: self.loop = True AppHelper.runConsoleEventLoop() self.loop = False
def pick(self, **kwargs): dialog = NSColorPanel.alloc().init() print('\n'.join(dir(NSColorPanel))) # Set look dialog.setColor_(Cocoa.NSColor.redColor()) dialog.setShowsAlpha_(True) dialog.setMode_(1) dialog.setFloatingPanel_(True) dialog.setUsingModalAppearance_(True) # Set Action dialog.setTarget_(self) dialog.setAction_('picked:') # Set behaviour dialog._setModal_(True) dialog.setWorksWhenModal_(True) dialog.setContinuous_(True) #dialog._orderFrontRelativeToWindow_(self) dialog.orderFrontRegardless() #dialog.orderFront_(None) dialog.makeKeyWindow() NSApp.activateIgnoringOtherApps_(True) AppHelper.runConsoleEventLoop()
def main(): #NSLog(u"main()") serviceProvider = ServiceTest.alloc().init() #NSLog(u"serviceProvider = %s", serviceProvider) NSRegisterServicesProvider(serviceProvider, u"PyObjCSimpleService") #NSLog(u"registered as PyObjCSimpleService") AppHelper.runConsoleEventLoop()
def notify(self, title, subtitle, text): """Create a user notification and display it.""" # if appImage: # source_img = AppKit.NSImage.alloc().initByReferencingFile_(appImage) # notification.set_identityImage_(source_img) # if contentImage: # source_img = AppKit.NSImage.alloc().initBy # notification.setContentImage_(source_img) notification = NSUserNotification.alloc().init() notification.setTitle_(str(title)) notification.setSubtitle_(str(subtitle)) notification.setInformativeText_(str(text)) notification.setSoundName_("NSUserNotificationDefaultSoundName") # notification.set_showsButtons_(True) # notification.setHasActionButton_(True) # notification.setHasReplyButton_ (True) # this will allow the user to enter text to "reply" # notification.setActionButtonTitle_("View") # notification.setUserInfo_({"action":"open_url", "value":url}) NSUserNotificationCenter.defaultUserNotificationCenter().setDelegate_(self) NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification) # Note that the notification center saves a *copy* of our object. AppHelper.runConsoleEventLoop()
def run_mainloop_with(self, target): """Start the OS's main loop to process asyncronous BLE events and then run the specified target function in a background thread. Target function should be a function that takes no parameters and optionally return an integer response code. When the target function stops executing or returns with value then the main loop will be stopped and the program will exit with the returned code. Note that an OS main loop is required to process asyncronous BLE events and this function is provided as a convenience for writing simple tools and scripts that don't need to be full-blown GUI applications. If you are writing a GUI application that has a main loop (a GTK glib main loop on Linux, or a Cocoa main loop on OSX) then you don't need to call this function. """ # Create background thread to run user code. self._user_thread = threading.Thread(target=self._user_thread_main, args=(target, )) self._user_thread.daemon = True self._user_thread.start() # Run main loop. This call will never return! try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: AppHelper.stopEventLoop() sys.exit(0)
def get_running_apps(): """Get a list of the running applications""" AppHelper.callLater(1, AppHelper.stopEventLoop) AppHelper.runConsoleEventLoop() # Get a list of running applications ws = AppKit.NSWorkspace.sharedWorkspace() apps = ws.runningApplications() return apps
def main(): configure_logging() global CRANKD_OPTIONS, CRANKD_CONFIG CRANKD_OPTIONS = process_commandline() CRANKD_CONFIG = load_config(CRANKD_OPTIONS) if "NSDistributed" in CRANKD_CONFIG: add_distributed_notifications(CRANKD_CONFIG["NSDistributed"]) if "NSWorkspace" in CRANKD_CONFIG: add_workspace_notifications(CRANKD_CONFIG['NSWorkspace']) if "SystemConfiguration" in CRANKD_CONFIG: add_sc_notifications(CRANKD_CONFIG['SystemConfiguration']) if "FSEvents" in CRANKD_CONFIG: add_fs_notifications(CRANKD_CONFIG['FSEvents']) if "NSNetService" in CRANKD_CONFIG: add_mdns_notifications(CRANKD_CONFIG['NSNetService']) if "CLLocation" in CRANKD_CONFIG: add_cl_notifications(CRANKD_CONFIG['CLLocation']) # We reuse our FSEvents code to watch for changes to our files and # restart if any of our libraries have been updated: add_conditional_restart( CRANKD_OPTIONS.config_file, "Configuration file %s changed" % CRANKD_OPTIONS.config_file) for m in filter(lambda i: i and hasattr(i, '__file__'), sys.modules.values()): if m.__name__ == "__main__": msg = "%s was updated" % m.__file__ else: msg = "Module %s was updated" % m.__name__ add_conditional_restart(m.__file__, msg) signal.signal(signal.SIGHUP, partial(restart, "SIGHUP received")) start_fs_events() # NOTE: This timer is basically a kludge around the fact that we can't reliably get # signals or Control-C inside a runloop. This wakes us up often enough to # appear tolerably responsive: CFRunLoopAddTimer( NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), 2.0, 0, 0, timer_callback, None), kCFRunLoopCommonModes) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: logging.info("KeyboardInterrupt received, exiting") sys.exit(0)
def frame(self): """ Returns a frame as a byte string of TIFF image data (or None). The byte string can be displayed with image(None, data=Camera.frame()). """ try: AppHelper.runConsoleEventLoop(installInterrupt=True) return str(self._delegate.frame.representations()[0].TIFFRepresentation().bytes()) except: return None
def watch(ime): txtObj = NSTextInputContext.alloc().initWithClient_(NSTextView.new()) obs = Observer.new().initWithValue_(txtObj) obs.ime = ime Foundation.NSNotificationCenter.defaultCenter().addObserver_selector_name_object_( obs, 'bundle:', NSTextInputContextKeyboardSelectionDidChangeNotification, None) AppHelper.runConsoleEventLoop()
def listen(callback): """Listen for song changes and trigger the callback for each.""" nc = Foundation.NSDistributedNotificationCenter.defaultCenter() observer = GetSongsObserver.alloc().initWithCallback_(callback) nc.addObserver_selector_name_object_(observer, 'getMySongs:', 'com.apple.iTunes.playerInfo', None) AppHelper.runConsoleEventLoop()
def main(): configure_logging() global CRANKD_OPTIONS, CRANKD_CONFIG CRANKD_OPTIONS = process_commandline() CRANKD_CONFIG = load_config(CRANKD_OPTIONS) if "NSDistributed" in CRANKD_CONFIG: add_distributed_notifications(CRANKD_CONFIG["NSDistributed"]) if "NSWorkspace" in CRANKD_CONFIG: add_workspace_notifications(CRANKD_CONFIG['NSWorkspace']) if "SystemConfiguration" in CRANKD_CONFIG: add_sc_notifications(CRANKD_CONFIG['SystemConfiguration']) if "FSEvents" in CRANKD_CONFIG: add_fs_notifications(CRANKD_CONFIG['FSEvents']) if "NSNetService" in CRANKD_CONFIG: add_mdns_notifications(CRANKD_CONFIG['NSNetService']) if "CLLocation" in CRANKD_CONFIG: add_cl_notifications(CRANKD_CONFIG['CLLocation']) # We reuse our FSEvents code to watch for changes to our files and # restart if any of our libraries have been updated: add_conditional_restart(CRANKD_OPTIONS.config_file, "Configuration file %s changed" % CRANKD_OPTIONS.config_file) for m in filter(lambda i: i and hasattr(i, '__file__'), sys.modules.values()): if m.__name__ == "__main__": msg = "%s was updated" % m.__file__ else: msg = "Module %s was updated" % m.__name__ add_conditional_restart(m.__file__, msg) signal.signal(signal.SIGHUP, partial(restart, "SIGHUP received")) start_fs_events() # NOTE: This timer is basically a kludge around the fact that we can't reliably get # signals or Control-C inside a runloop. This wakes us up often enough to # appear tolerably responsive: CFRunLoopAddTimer( NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), 2.0, 0, 0, timer_callback, None), kCFRunLoopCommonModes ) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: logging.info("KeyboardInterrupt received, exiting") sys.exit(0)
def loop(self): # Check if camera isn't detected cameras = [] for camera in QTKit.QTCaptureDevice.inputDevices(): cameras += [str(camera)] if cameraPort not in cameras: # Display message print "Camera not detected" # Exit exit() # Initialize camera camera = QTKit.QTCaptureDevice.inputDevices()[cameras.index( cameraPort)] error = None if not camera.open_(error): exit() # Create capture session captureSession = QTKit.QTCaptureSession.alloc().init() # Create input device from camera inputDevice = QTKit.QTCaptureDeviceInput.alloc( ).initWithDevice_(camera) if not captureSession.addInput_error_(inputDevice, error): exit() # Create output device outputDevice = QTKit.QTCaptureDecompressedVideoOutput.alloc( ).init() # Set fames/second outputDevice.setMinimumVideoFrameInterval_(cameraFrameDelay) outputDevice.setAutomaticallyDropsLateVideoFrames_(True) # Set camera size outputDevice.setPixelBufferAttributes_({ kCVPixelBufferWidthKey: cameraWidth, kCVPixelBufferHeightKey: cameraHeight }) # Delegate frame task outputDevice.setDelegate_(self) if not captureSession.addOutput_error_(outputDevice, error): exit() # Start the capture session captureSession.startRunning() # Start main loop AppHelper.runConsoleEventLoop(installInterrupt=True)
def _getRunningApps(cls): '''Get a list of the running applications''' def runLoopAndExit(): AppHelper.stopEventLoop() AppHelper.callLater(1, runLoopAndExit) AppHelper.runConsoleEventLoop() # Get a list of running applications ws = AppKit.NSWorkspace.sharedWorkspace() apps = ws.runningApplications() return apps
def setupGuiEnvironment(cb): if sys.platform == 'darwin': from PyObjCTools import AppHelper m = {'run': cb} proxy = _jproxy.JProxy('java.lang.Runnable', m) cbthread = _jclass.JClass("java.lang.Thread")(proxy) cbthread.start() AppHelper.runConsoleEventLoop() else: cb()
def main(): nc = NSWorkspace.sharedWorkspace().notificationCenter() observer = Observer.new() nc.addObserver_selector_name_object_( observer, "handle:", NSWorkspaceDidActivateApplicationNotification, None ) AppHelper.runConsoleEventLoop(installInterrupt=True)
def setupGuiEnvironment(cb): if _sys.platform == 'darwin': from PyObjCTools import AppHelper m = {'run': cb} proxy = _jproxy.JProxy('java.lang.Runnable', m) cbthread = _jclass.JClass("java.lang.Thread")(proxy) cbthread.start() AppHelper.runConsoleEventLoop() else: cb()
def frame(self): """ Returns a frame as a byte string of TIFF image data (or None). The byte string can be displayed with image(None, data=Camera.frame()). """ try: AppHelper.runConsoleEventLoop(installInterrupt=True) return str(self._delegate.frame.representations() [0].TIFFRepresentation().bytes()) except: return None
def _getRunningApps(cls): '''Get a list of the running applications''' def runLoopAndExit(): AppHelper.stopEventLoop() AppHelper.callLater(1, runLoopAndExit) AppHelper.runConsoleEventLoop() # Get a list of running applications ws = AppKit.NSWorkspace.sharedWorkspace() apps = ws.runningApplications() return apps
def _runMainRunLoop(self): # Create background thread to run user code. self._user_thread = threading.Thread(target=self._user_thread_main) self._user_thread.daemon = True self._user_thread.start() # Run main loop. This call will never return! try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: AppHelper.stopEventLoop() sys.exit(0)
def main(self): # Callback that quits after a frame is captured NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(0.1, self, "quitMainLoop:", None, True) # Turn on the camera and start the capture self.startImageCapture(None) # Start Cocoa's main event loop AppHelper.runConsoleEventLoop(installInterrupt=True) print "Frame capture completed."
def main(self): # Callback that quits after a frame is captured NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_( 0.1, self, 'quitMainLoop:', None, True) # Turn on the camera and start the capture self.startImageCapture(None) # Start Cocoa's main event loop AppHelper.runConsoleEventLoop(installInterrupt=True) print "Frame capture completed."
def loop(self) : # Check if camera isn't detected cameras = [] for camera in QTKit.QTCaptureDevice.inputDevices() : cameras += [str(camera)] if cameraPort not in cameras : # Display message print "Camera not detected" # Exit exit() # Initialize camera camera = QTKit.QTCaptureDevice.inputDevices()[cameras.index(cameraPort)] error = None if not camera.open_(error) : exit() # Create capture session captureSession = QTKit.QTCaptureSession.alloc().init() # Create input device from camera inputDevice = QTKit.QTCaptureDeviceInput.alloc().initWithDevice_(camera) if not captureSession.addInput_error_(inputDevice, error) : exit() # Create output device outputDevice = QTKit.QTCaptureDecompressedVideoOutput.alloc().init() # Set fames/second outputDevice.setMinimumVideoFrameInterval_(cameraFrameDelay) outputDevice.setAutomaticallyDropsLateVideoFrames_(True) # Set camera size outputDevice.setPixelBufferAttributes_({ kCVPixelBufferWidthKey: cameraWidth, kCVPixelBufferHeightKey: cameraHeight }) # Delegate frame task outputDevice.setDelegate_(self) if not captureSession.addOutput_error_(outputDevice, error) : exit() # Start the capture session captureSession.startRunning() # Start main loop AppHelper.runConsoleEventLoop(installInterrupt = True)
def requestLivePhotoResources(self, version=PHOTOS_VERSION_CURRENT): """ return the photos and video components of a live video as [PHAssetResource] """ with objc.autorelease_pool(): options = Photos.PHLivePhotoRequestOptions.alloc().init() options.setNetworkAccessAllowed_(True) options.setVersion_(version) options.setDeliveryMode_( Photos.PHVideoRequestOptionsDeliveryModeHighQualityFormat ) delegate = PhotoKitNotificationDelegate.alloc().init() self.nc.addObserver_selector_name_object_( delegate, "liveNotification:", None, None ) self.live_photo = None def handler(result, info): """ result handler for requestLivePhotoForAsset:targetSize:contentMode:options:resultHandler: """ if not info["PHImageResultIsDegradedKey"]: self.live_photo = result self.info = info self.nc.postNotificationName_object_( PHOTOKIT_NOTIFICATION_FINISHED_REQUEST, self ) try: self.manager.requestLivePhotoForAsset_targetSize_contentMode_options_resultHandler_( self.asset, Photos.PHImageManagerMaximumSize, Photos.PHImageContentModeDefault, options, handler, ) AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: AppHelper.stopEventLoop() finally: pass asset_resources = Photos.PHAssetResource.assetResourcesForLivePhoto_( self.live_photo ) # not sure why this is needed -- some weird ref count thing maybe # if I don't do this, memory leaks data = copy.copy(asset_resources) del asset_resources return data
def run(reminder, *reminders): reminders = [reminder] + list(reminders) sharedapp = NSApplication.sharedApplication() app = App.alloc().init() app.reminder = " ".join(reminders) sharedapp.setDelegate_(app) app.applicationDidFinishLaunching_(None) print("Reminder saved") print("Waiting ...") try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: print('Interrupt, pending reminders:') app.show_reminder()
def __init__(self): self.cf = BLE_CF.BLE_CrazyFlie() # add methods that the crazyflie executes #Pool().map(self.cf.add_callback, self._preCtrlFly()) Pool().map(self.cf.add_callback, self._liveFly()) #self.cf.add_callback(self._preCtrlFly) #self.cf.add_callback(self._liveFly) manager = CBCentralManager.alloc() manager.initWithDelegate_queue_options_(self.cf, None, None) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: AppHelper.stopEventLoop()
def _setNotification(self, timeout=0, notificationStr=None, callbackFn=None, callbackArgs=None, callbackKwargs=None): if callable(callbackFn): self.callbackFn = callbackFn if isinstance(callbackArgs, tuple): self.callbackArgs = callbackArgs else: self.callbackArgs = tuple() if isinstance(callbackKwargs, dict): self.callbackKwargs = callbackKwargs self.observerRes = None pid = self._getPid() err, observer = AXObserverCreate(pid, observerCallback, None) if err != kAXErrorSuccess: _setError(err, 'Could not create observer for notification') err = AXObserverAddNotification( observer, self.ref, notificationStr, self ) if err != kAXErrorSuccess: _setError(err, 'Could not add notification to observer') #Add observer source to run loop CFRunLoopAddSource( CFRunLoopGetCurrent(), AXObserverGetRunLoopSource(observer), kCFRunLoopDefaultMode ) # Set the signal handlers prior to running the run loop oldSigIntHandler = MachSignals.signal(signal.SIGINT, _sigHandler) # If an error occurs (return value is SIG_ERR), continue as it's not fatal AppHelper.runConsoleEventLoop( mode=kCFRunLoopDefaultMode, installInterrupt=False, maxTimeout=timeout, ) MachSignals.signal(signal.SIGINT, oldSigIntHandler) err = AXObserverRemoveNotification(observer, self.ref, notificationStr) if err != kAXErrorSuccess: _setError(err, 'Could not remove notification from observer') return self.observerRes
def _setNotification(self, timeout=0, notificationStr=None, callbackFn=None, callbackArgs=None, callbackKwargs=None): if callable(callbackFn): self.callbackFn = callbackFn if isinstance(callbackArgs, tuple): self.callbackArgs = callbackArgs else: self.callbackArgs = tuple() if isinstance(callbackKwargs, dict): self.callbackKwargs = callbackKwargs self.observerRes = None pid = self._getPid() err, observer = AXObserverCreate(pid, observerCallback, None) if err != kAXErrorSuccess: _setError(err, 'Could not create observer for notification') err = AXObserverAddNotification(observer, self.ref, notificationStr, self) if err != kAXErrorSuccess: _setError(err, 'Could not add notification to observer') #Add observer source to run loop CFRunLoopAddSource(CFRunLoopGetCurrent(), AXObserverGetRunLoopSource(observer), kCFRunLoopDefaultMode) # Set the signal handlers prior to running the run loop oldSigIntHandler = MachSignals.signal(signal.SIGINT, _sigHandler) # If an error occurs (return value is SIG_ERR), continue as it's not fatal AppHelper.runConsoleEventLoop( mode=kCFRunLoopDefaultMode, installInterrupt=False, maxTimeout=timeout, ) MachSignals.signal(signal.SIGINT, oldSigIntHandler) err = AXObserverRemoveNotification(observer, self.ref, notificationStr) if err != kAXErrorSuccess: _setError(err, 'Could not remove notification from observer') return self.observerRes
def main(): global gMLNotification global gImportFullPath # Anything to process? Also needed for mmap function. fileSize = os.stat(gImportFullPath).st_size if fileSize > 0: # Setup our app environment. app=AppKit.NSApplication.sharedApplication() theFile = open(gImportFullPath) importData = mmap.mmap(theFile.fileno(), fileSize, access=mmap.ACCESS_READ) # Get lines with a non-zero error code, extracting the date, time, error object, and error number rePattern = re.compile (r"(\d\d\d\d-\d\d-\d\d) (\d\d\:\d\d:\d\d).*?\t(.*?)\t([123456789]\d*)\t(.*)") # Banner notifications stay up for about 6 seconds, but there may be delays posting them. # We need to hang around long enough to handle a user clicking on the notification. t = Timer(9.0, stopRunLoop) t.start() allMatches = rePattern.findall (importData) print "Found",len (allMatches),"errors" hadMatch = False matchNum = -1 n = [] # This should be the last logged error in import log. for match in allMatches: matchNum += 1 n.append (None) dt = datetime.strptime(match[0] + " " + match[1], "%Y-%m-%d %H:%M:%S") if (datetime.now() - dt).seconds < 15: n[matchNum] = gMLNotification.notify ("FileMaker Import Error",match[2],match[3] + ": " + match[4],gImportFullPath) print "notification",matchNum,"added" print match time.sleep (0.5) hadMatch = True if hadMatch: # The timer set up previously will kill the event loop after the notifications have expired. AppHelper.runConsoleEventLoop(installInterrupt=True) else: # There were no matches, and nothing to do, just exit now. sys.exit(0)
def _layout_watcher(self): layout = self class LayoutWatchingCallback(AppKit.NSObject): def layoutChanged_(self, event): log.info('Mac keyboard layout changed, updating') layout._update_layout() center = Foundation.NSDistributedNotificationCenter.defaultCenter() watcher_callback = LayoutWatchingCallback.new() center.addObserver_selector_name_object_suspensionBehavior_( watcher_callback, 'layoutChanged:', 'com.apple.Carbon.TISNotifySelectedKeyboardInputSourceChanged', None, Foundation.NSNotificationSuspensionBehaviorDeliverImmediately) AppHelper.runConsoleEventLoop(installInterrupt=True)
def _runloop_thread(self): try: with objc.autorelease_pool(): queue_ptr = objc.objc_object(c_void_p=self._dispatch_queue) self._manager = CoreBluetooth.CBCentralManager.alloc() self._manager.initWithDelegate_queue_options_( self, queue_ptr, None) #self._peripheral_manager = CoreBluetooth.CBPeripheralManager.alloc() #self._peripheral_manager.initWithDelegate_queue_options_(self, queue_ptr, None) self._runloop_started_lock.set() AppHelper.runConsoleEventLoop(installInterrupt=True) except Exception as e: log.exception(e) log.info("Exiting runloop")
def test_console(): from PyObjCTools import AppHelper from ConsoleReactor import ConsoleReactor host = '127.0.0.1' port = 0 interpreterPath = sys.executable scriptPath = unicode(os.path.abspath('tcpinterpreter.py')) commandReactor = ConsoleReactor.alloc().init() interp = AsyncPythonInterpreter.alloc().initWithHost_port_interpreterPath_scriptPath_commandReactor_(host, port, interpreterPath, scriptPath, commandReactor) interp.connect() class ThisEventLoopStopper(NSObject): def interpFinished_(self, notification): AppHelper.stopEventLoop() stopper = ThisEventLoopStopper.alloc().init() NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(stopper, 'interpFinished:', u'AsyncPythonInterpreterClosed', interp) AppHelper.runConsoleEventLoop(installInterrupt=True)
def test_console(): from PyObjCTools import AppHelper from ConsoleReactor import ConsoleReactor host = '127.0.0.1' port = 0 interpreterPath = sys.executable scriptPath = unicode(os.path.abspath('tcpinterpreter.py')) commandReactor = ConsoleReactor.alloc().init() interp = AsyncPythonInterpreter.alloc().initWithHost_port_interpreterPath_scriptPath_commandReactor_(host, port, interpreterPath, scriptPath, commandReactor) interp.connect() class ThisEventLoopStopper(NSObject): def interpFinished_(self, notification): AppHelper.stopEventLoop() stopper = ThisEventLoopStopper.alloc().init() NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(stopper, 'interpFinished:', u'AsyncPythonInterpreterClosed', interp) AppHelper.runConsoleEventLoop(installInterrupt=True)
def main(): add_workspace_notifications(load_workspace_notifications()) # NOTE: This timer is basically a kludge around the fact that we can't reliably get # signals or Control-C inside a runloop. This wakes us up often enough to # appear tolerably responsive: CFRunLoopAddTimer( NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), 2.0, 0, 0, timer_callback, None), kCFRunLoopCommonModes) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: logging.info("KeyboardInterrupt received, exiting") sys.exit(0)
def main(): global CRANKD_OPTIONS, CRANKD_CONFIG CRANKD_OPTIONS = process_commandline() CRANKD_CONFIG = load_config(CRANKD_OPTIONS) # We replace the initial program name with one which won't break if relative paths are used: sys.argv[0] = os.path.realpath(sys.argv[0]) configure_logging() logging.info("Loaded configuration from %s" % CRANKD_OPTIONS.config_file) if "NSWorkspace" in CRANKD_CONFIG: add_workspace_notifications(CRANKD_CONFIG['NSWorkspace']) if "SystemConfiguration" in CRANKD_CONFIG: add_sc_notifications(CRANKD_CONFIG['SystemConfiguration']) if "FSEvents" in CRANKD_CONFIG: add_fs_notifications(CRANKD_CONFIG['FSEvents']) # We reuse our FSEvents code to watch for changes to our files and # restart if any of our libraries have been updated: add_conditional_restart(CRANKD_OPTIONS.config_file, "Configuration file %s changed" % CRANKD_OPTIONS.config_file) for (m_name, m_file) in [(k, v) for k, v in sys.modules.iteritems() if hasattr(v, '__file__')]: add_conditional_restart(m_file.__file__, "Module %s was updated" % m_name) signal.signal(signal.SIGHUP, partial(restart, "SIGHUP received")) start_fs_events() # NOTE: This timer is basically a kludge around the fact that we can't reliably get # signals or Control-C inside a runloop. This wakes us up often enough to # appear tolerably responsive: CFRunLoopAddTimer( NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), 5.0, 0, 0, timer_callback, None), kCFRunLoopCommonModes ) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: logging.info("KeyboardInterrupt received, exiting") sys.exit(0)
def start_screen_state_observer(): ''' Kill the main loop whenever screen turns off, so that we dont keep getting dialogs and sounds even when laptop is unattended. Start the main loop again once screen is on again. ''' logging.info('ScreenStateObserver process started.') setproctitle.setproctitle(mp.current_process().name) nc = Foundation.NSDistributedNotificationCenter.defaultCenter() screen_state_observer = ScreenStateObserver.new() nc.addObserver_selector_name_object_(screen_state_observer, 'screenOffHandler:', 'com.apple.screenIsLocked', None) nc.addObserver_selector_name_object_(screen_state_observer, 'screenOnHandler:', 'com.apple.screenIsUnlocked', None) AppHelper.runConsoleEventLoop()
def setup_event_loop(self): if NSWorkspace is None: return ws = NSWorkspace.sharedWorkspace() self.notificationCenter = ws.notificationCenter() self.handler = NotificationHandler.new() self.handler.sleep_callback = self.client.suspend self.handler.wake_callback = self.client.resume self.notificationCenter.addObserver_selector_name_object_( self.handler, "handleSleepNotification:", AppKit.NSWorkspaceWillSleepNotification, None) self.notificationCenter.addObserver_selector_name_object_( self.handler, "handleWakeNotification:", AppKit.NSWorkspaceDidWakeNotification, None) log("starting console event loop with notifcation center=%s and handler=%s", self.notificationCenter, self.handler) if self.blocking: #this is for running standalone AppHelper.runConsoleEventLoop(installInterrupt=self.blocking)
def main(): add_workspace_notifications(load_workspace_notifications()) # NOTE: This timer is basically a kludge around the fact that we can't reliably get # signals or Control-C inside a runloop. This wakes us up often enough to # appear tolerably responsive: CFRunLoopAddTimer( NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), 2.0, 0, 0, timer_callback, None), kCFRunLoopCommonModes ) try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: logging.info("KeyboardInterrupt received, exiting") sys.exit(0)
def _layout_watcher(self): layout = self class LayoutWatchingCallback(AppKit.NSObject): def layoutChanged_(self, event): log.info('Mac keyboard layout changed, updating') layout._update_layout() center = Foundation.NSDistributedNotificationCenter.defaultCenter() watcher_callback = LayoutWatchingCallback.new() center.addObserver_selector_name_object_suspensionBehavior_( watcher_callback, 'layoutChanged:', 'com.apple.Carbon.TISNotifySelectedKeyboardInputSourceChanged', None, Foundation.NSNotificationSuspensionBehaviorDeliverImmediately ) AppHelper.runConsoleEventLoop(installInterrupt=True)
def discover(devToFind=None, timeout=2, connectableOnly=False): # do this for every function to ensure user not ignoring dependencies if( checkDep() == False ): quit() devices = list(()) # check if library is properly loaded yet global LOADED global DEBUG if( LOADED == False ): helpers.debugMsg("[WARNING] ...bleach module not loaded, calling bleach.load() now, this should be called at start of main program") if( load() == False ): helpers.debugMsg("[WARNING] ...bleach module failed to load") return None # MAC discovery here if( OSTAG == "MAC" ): try: # Using CoreBluetooth import CoreBluetooth from PyObjCTools import AppHelper bleManage = CoreBluetooth.CBCentralManager.alloc() if( bleManage is not None ): helpers.debugMsg( "[INFO] CBCentralManager loaded OK") bleManage.init() # create the CBManager Delegate myDelegate = cbmanagerDelegate.managerDelegate() myDelegate.setTimeout(timeout) myDelegate.setParams(connectableOnly, DEBUG) bleManage.initWithDelegate_queue_options_(myDelegate, None, None) AppHelper.runConsoleEventLoop() # grab the device list devices = myDelegate.getDevices() else: helpers.debugMsg("[WARNING] CBCentralManager.alloc() returned <None>") except Exception as err: helpers.debugMsg("[WARNING] BLEach discover() failed with error <"+str(err)+">") # send back the list of devices return devices
def wait_for(self, notification=None, filter_=None, timeout=5): self.callback_result = None @PAXObserverCallback def _callback(observer, element, notification, refcon): logger.debug("CALLBACK") logger.debug("%s, %s, %s, %s" % (observer, element, notification, refcon)) ret_element = self.ref.__class__(element) if filter_(ret_element): self.callback_result = ret_element observer = PAXObserverCreate(self.ref.pid, _callback) PAXObserverAddNotification(observer, self.ref.ref, notification, id(self.ref.ref)) # Add observer source to run loop CFRunLoopAddSource( CFRunLoopGetCurrent(), AXObserverGetRunLoopSource(observer), NSDefaultRunLoopMode, ) def event_stopper(): end_time = time.time() + timeout while time.time() < end_time: if self.callback_result is not None: break AppHelper.callAfter(AppHelper.stopEventLoop) event_watcher = threading.Thread(target=event_stopper) event_watcher.daemon = True event_watcher.start() # Set the signal handlers prior to running the run loop oldSigIntHandler = MachSignals.signal(signal.SIGINT, _sigHandler) AppHelper.runConsoleEventLoop() MachSignals.signal(signal.SIGINT, oldSigIntHandler) PAXObserverRemoveNotification(observer, self.ref.ref, notification) return self.callback_result
def setup_event_loop(self): if NSWorkspace is None: return ws = NSWorkspace.sharedWorkspace() self.notificationCenter = ws.notificationCenter() self.handler = NotificationHandler.new() self.handler.sleep_callback = self.client.suspend self.handler.wake_callback = self.client.resume self.notificationCenter.addObserver_selector_name_object_( self.handler, "handleSleepNotification:", AppKit.NSWorkspaceWillSleepNotification, None) self.notificationCenter.addObserver_selector_name_object_( self.handler, "handleWakeNotification:", AppKit.NSWorkspaceDidWakeNotification, None) log( "starting console event loop with notifcation center=%s and handler=%s", self.notificationCenter, self.handler) if self.blocking: #this is for running standalone AppHelper.runConsoleEventLoop(installInterrupt=self.blocking)
def getAppRefByLocalizedName(cls, name): '''getAppRefByLocalizedName - Get the top level element for the application with the specified localized name, such as VMware Fusion. Wildcards are also allowed. ''' # Refresh the runningApplications list def runLoopAndExit(): AppHelper.stopEventLoop() AppHelper.callLater(1, runLoopAndExit) AppHelper.runConsoleEventLoop() # Get a list of running applications ws = AppKit.NSWorkspace.sharedWorkspace() apps = ws.runningApplications() for app in apps: if fnmatch.fnmatch(app.localizedName(), name): pid = app.processIdentifier() return cls.getAppRefByPid(pid) raise ValueError('Specified application not found in running apps.')
def main(): # Pre-populate skip set with all existing screen shots firstLoadFileList = os.listdir(WATCH_PATH) for filename in firstLoadFileList: if MAC_SCREENSHOT_REGEX.match(filename): macgrab.addUploaded(filename) # Listen for filesystem events at the watch_path addFSEventListener() # Keep alive CFRunLoopAddTimer(NSRunLoop.currentRunLoop().getCFRunLoop(), CFRunLoopTimerCreate(None, CFAbsoluteTimeGetCurrent(), INTERVAL_TO_CHECK_FOR_PROGRAM_EXIT, 0, 0, onTimerCallback, None), kCFRunLoopCommonModes) # respond to control-c to terminate try: AppHelper.runConsoleEventLoop(installInterrupt=True) except KeyboardInterrupt: print "exiting"
def getAppRefByLocalizedName(cls, name): '''getAppRefByLocalizedName - Get the top level element for the application with the specified localized name, such as VMware Fusion. Wildcards are also allowed. ''' # Refresh the runningApplications list def runLoopAndExit(): AppHelper.stopEventLoop() AppHelper.callLater(1, runLoopAndExit) AppHelper.runConsoleEventLoop() # Get a list of running applications ws = AppKit.NSWorkspace.sharedWorkspace() apps = ws.runningApplications() for app in apps: if fnmatch.fnmatch(app.localizedName(), name): pid = app.processIdentifier() return cls.getAppRefByPid(pid) raise ValueError('Specified application not found in running apps.')
def do_run_query_loop0(query): """docstring for do_run_loop""" class MyEventHandlers(): def __init__(self, code, description=""): self.code = code self.description = description def __str__(self): return "%s (%d)" % (self.description, self.code) def gathering_(self, notification): print notification.name() # NSMetadataQueryGatheringProgressNotification def did_update_(self, notification): print "name", notification.name() print "userInfo is: " , notification.userInfo() def did_finish_(self, notification): print notification.name() # NSMetadataQueryDidFinishGatheringNotification # Stops the event loop (if started by runConsoleEventLoop) or sends the NSApplication a terminate: message. didStop = AppHelper.stopEventLoop() if didStop: print "stopping the event loop " raise ValueError, "this will stop you!" my_handlers = MyEventHandlers(1) nc.addObserver_selector_name_object_(my_handlers, "did_finish:", NSMetadataQueryDidFinishGatheringNotification, query) nc.addObserver_selector_name_object_(my_handlers, "did_update:", NSMetadataQueryDidUpdateNotification, query) nc.addObserver_selector_name_object_(my_handlers, "gathering:", NSMetadataQueryGatheringProgressNotification, query) query.startQuery() print "Listening for new tunes...." try: AppHelper.runConsoleEventLoop( mode = NSDefaultRunLoopMode) except ValueError, e: print "ValueError", e
def run(self, installSignalHandlers=True): """ Start the reactor. """ self._postQueue = Queue.Queue() # start select() thread: self.interleave(AppHelper.callAfter, installSignalHandlers=installSignalHandlers) #if installSignalHandlers: # self.callLater(0, self._installSignalHandlersAgain) # add cleanup events: self.addSystemEventTrigger("after", "shutdown", AppHelper.stopEventLoop) self.addSystemEventTrigger("after", "shutdown", lambda: self._postQueue.put(None)) AppHelper.runConsoleEventLoop(installInterrupt=True) if not self._stopping: # if event loop exited without reactor.stop() being # called. At this point events from select() thread will # be added to _postQueue self.stop() while 1: try: f = self._postQueue.get(timeout=0.01) except Queue.Empty: continue else: if f is None: break try: f() except: log.err()
def run(): # enter the main event loop AppHelper.runConsoleEventLoop()
# from ConsoleReactor import ConsoleReactor # host = '127.0.0.1' # port = 0 # interpreterPath = sys.executable # scriptPath = unicode(os.path.abspath('tcpinterpreter.py')) # commandReactor = ConsoleReactor.alloc().init() # interp = AsyncPythonInterpreter.alloc().initWithHost_port_interpreterPath_scriptPath_commandReactor_(host, port, interpreterPath, scriptPath, commandReactor) # interp.connect() query = NSMetadataQuery.alloc().init() query.setPredicate_(NSPredicate.predicateWithFormat_( 'kMDItemKind = "Aperture Library"' )) scopes = [NSMetadataQueryUserHomeScope] query.setSearchScopes_( scopes ) class ThisEventLoopStopper(NSObject): def interpFinished_(self, notification): AppHelper.stopEventLoop() stopper = ThisEventLoopStopper.alloc().init() NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(stopper, 'interpFinished:', NSMetadataQueryDidFinishGatheringNotification, query) query.startQuery() # NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(stopper, 'interpFinished:', u'AsyncPythonInterpreterClosed', interp) AppHelper.runConsoleEventLoop(installInterrupt=True) query.stopQuery() print "count: ", len(query.results()) for item in query.results(): print "item: ", item.valueForAttribute_("kMDItemPath")
def main(): serviceProvider = TinyURLService.alloc().init() NSRegisterServicesProvider(serviceProvider, u"TinyURLService") AppHelper.runConsoleEventLoop()
def start_event_loop(): AppHelper.runConsoleEventLoop(installInterrupt=True)
def run(self): #this is for running standalone log("starting console event loop") self.event_loop_started = True import PyObjCTools.AppHelper as AppHelper #@UnresolvedImport AppHelper.runConsoleEventLoop(installInterrupt=True)
# Find the path to the just inserted volume path = aNotification.userInfo()['NSDevicePath'] for aFile in os.listdir(path): if readTheseFiles.match(aFile): # Found a readme file, try to open it using the Workspace API fullPath = os.path.join(path, aFile) success, app, None = workspace.getInfoForFile_application_type_( fullPath) if not success: NSLog("Failed to find application to open file %s", fullPath) return workspace.openFile_withApplication_(fullPath, app) # Create an instance of our notification handler, and ask the workspace # notification center to tell us when a new volume is mounted. workspace = NSWorkspace.sharedWorkspace() notificationCenter = workspace.notificationCenter() notificationHandler = NotificationHandler.new() notificationCenter.addObserver_selector_name_object_( notificationHandler, "handleMountNotification:", NSWorkspaceDidMountNotification, None) NSLog("Listening for mount notifications....") AppHelper.runConsoleEventLoop()
''' This python script listens for distributed notifications from iTunes of new songs playing, works alot better then constantly polling. ''' import Foundation from AppKit import * from PyObjCTools import AppHelper class GetSongs(NSObject): def getMySongs_(self, song): song_details = {} ui = song.userInfo() song_details = dict(zip(ui.keys(), ui.values())) print song_details nc = Foundation.NSDistributedNotificationCenter.defaultCenter() GetSongs = GetSongs.new() nc.addObserver_selector_name_object_(GetSongs, 'getMySongs:', 'com.apple.iTunes.playerInfo',None) NSLog("Listening for new tunes....") AppHelper.runConsoleEventLoop()
def startLoop(self): NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_( 0.0, self, 'onPumpFirst:', None, False) AppHelper.runConsoleEventLoop()
def run(self): #this is for running standalone AppHelper.runConsoleEventLoop(installInterrupt=True)