def __init__(self, settings_manager): ThreadQueueBase.__init__(self, name="CaptureManager") try: self._settings_manager = settings_manager self._host_manager = host.HostManager(settings_manager) # get the correct plugin for the camera home = os.path.expanduser("~") cameras_folder = home + "/.pysces_asi/cameras" camera_plugin_name = self._settings_manager.get( ["camera"])['camera'] camera.clear_plugins_list() camera.load_camera_plugins(cameras_folder) self._camera_manager = camera.cameras[ camera_plugin_name](settings_manager) self._output_task_handler = output_task_handler.OutputTaskHandler( settings_manager) except Exception as ex: traceback.print_exc() self._settings_manager.set( {"output": "CameraManager> ** ERROR! ** " + ex.args[0]}) self.exit() raise ex
def start(self): """ Starts the proxy running. This must be called from within the process where the proxy is going to be used. """ ThreadQueueBase.__init__(self, name="SettingsManagerProxy") self.started = True
def __init__(self, settings_manager): ThreadQueueBase.__init__(self, name="CameraManager") try: # check that camera is connected if not self.is_connected(): raise GphotoError("No camera detected") if settings_manager.get(['camera_full_auto_clear'])['camera_full_auto_clear']: settings_manager.set( {"output": "CameraManager> Clearing camera card"}) # get the camera configs settings_manager.set( {"output": "CameraManager> Downloading settings from camera - please wait"}) self.camera_configs = self.download_configs() self.capture_mode = None except Exception as ex: self.exit() raise ex
def __init__(self, settings_manager): self.__pipelined_lock = threading.Lock() ThreadQueueBase.__init__(self, name="OutputTaskHandler", workers=multiprocessing.cpu_count( ), maxsize=multiprocessing.cpu_count() + 2) # create a processing pool to produce the outputs asyncronously - this # has as many workers as there are CPU cores self._processing_pool = ProcessQueueBase( workers=multiprocessing.cpu_count(), name="Processing Pool") # multiprocessing.cpu_count() # create a processing pool to produce outputs in the order that their respective image types # are recieved from the camera (useful for creating keograms for # example) self._pipelined_processing_pool = ProcessQueueBase( workers=1, name="Pipelined Processing Pool") # load the output creation functions home = os.path.expanduser("~") clear_plugins_list() load_output_functions(os.path.normpath(home + "/.pysces_asi/outputs")) # check to see if we need a web-server mounted try: web_server = settings_manager.get(["web_server"])['web_server'] except KeyError: web_server = None if (web_server is None): self._network_manager = None else: # create NetworkManager object to handle copying outputs to the # webserver self._network_manager = network.NetworkManager(settings_manager) self._settings_manager = settings_manager
def __init__(self): ThreadQueueBase.__init__(self, name="SettingsManager") # define method to string mappings - notice that these should be the # thread safe public methods! self._methods = { "get": self.get, "set": self.set, "create": self.create, "register": self.register, "unregister": self.unregister, "operate": self.operate, "destroy proxy": self._commit_destroy_proxy, } # self._manager = Manager() # self._manager.Queue() self._remote_input_queue = multiprocessing.Queue() # create thread to handle remote tasks self.remote_task_thread = Thread(target=self._process_remote_tasks) self.remote_task_thread.start() try: # define private attributes self.__variables = {} self.__callbacks = {} self.__callback_ids = {} self._output_queues = {} # hard code settings file location and create a parser home = os.path.expanduser("~") self.__settings_file_parser = settings_file_parser.SettingsFileParser(home + "/.pysces_asi/settings.txt") # create an output variable - this is used instead of printing to stdout, making it easier # for a top layer application (e.g. a GUI) to access this data self.__create("output", "") # load settings file settings = self.__settings_file_parser.get_settings() # store settings in variables for key in list(settings.keys()): self.__create(key, settings[key]) # create persistant storage class self.__persistant_storage = persist.PersistantStorage(home + "/.pysces_asi", self) # load persistant values into variables persistant_data = self.__persistant_storage.get_persistant_data() for key in list(persistant_data.keys()): self.__create(key, persistant_data[key], persistant=True) except Exception as ex: # if an exception occurs then we need to shut down the threads and # manager before exiting self._stay_alive = False self._remote_input_queue.put(None) self.remote_task_thread.join() self._remote_input_queue.close() ThreadQueueBase.exit(self) raise ex