def test_dataflow_unsub(self): """ Check the dataflow is automatically unsubscribed when the subscriber disappears. """ comp = model.createInNewContainer("testscont", MyComponent, {"name":"MyComp"}) comp2 = model.createInNewContainer("testscont2", MyComponent, {"name":"MyComp2"}) self.count = 0 self.data_arrays_sent = 0 comp.data.reset() # special hidden function that will directly ask the original DF nlisteners = comp.data._count_listeners() self.assertEqual(nlisteners, 0) comp2.sub(comp.data) time.sleep(0.5) # comp2.unsub() count_arrays = comp2.get_data_count() logging.info("received %d arrays", count_arrays) nlisteners = comp.data._count_listeners() logging.info("orig has %d listeners", nlisteners) comp2.terminate() model.getContainer("testscont2").terminate() logging.info("comp2 should now be disappeared") time.sleep(0.4) nlisteners = comp.data._count_listeners() self.assertEqual(nlisteners, 0) comp.terminate() model.getContainer("testscont").terminate() time.sleep(0.1) # give it some time to terminate
def test_component(self): cont, comp = model.createInNewContainer("testscont", model.HwComponent, {"name":"MyHwComp", "role":"affected"}) self.assertEqual(comp.name, "MyHwComp") cont2, comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2.affects.value.append(comp) self.assertEqual(len(comp2.affects.value), 1) for c in comp2.affects.value: self.assertTrue(isinstance(c, model.ComponentBase)) self.assertEqual(c.name, "MyHwComp") self.assertEqual(c.role, "affected") comp2_new = model.getObject("testscont2", "MyHwComp2") self.assertEqual(comp2_new.name, "MyHwComp2") self.assertEqual(len(comp2_new.affects.value), 1) comp.terminate() comp2.terminate() cont.terminate() cont2.terminate() time.sleep(0.1) # give it some time to terminate
def test_dataflow(self): comp = model.createInNewContainer("testscont", MyComponent, {"name":"MyComp"}) self.assertEqual(comp.name, "MyComp") comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2._set_affects(set([comp])) self.assertEqual(len(comp2.affects), 1) comp_indir = list(comp2.affects)[0] self.count = 0 self.data_arrays_sent = 0 comp_indir.data.reset() comp_indir.data.subscribe(self.receive_data) time.sleep(0.5) comp_indir.data.unsubscribe(self.receive_data) count_end = self.count print "received %d arrays over %d" % (self.count, self.data_arrays_sent) time.sleep(0.1) self.assertEqual(count_end, self.count) comp.terminate() comp2.terminate() model.getContainer("testscont").terminate() model.getContainer("testscont2").terminate() time.sleep(0.1) # give it some time to terminate
def test_component(self): comp = model.createInNewContainer("testscont", model.HwComponent, {"name":"MyHwComp", "role":"affected"}) self.assertEqual(comp.name, "MyHwComp") comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2._set_affects(set([comp])) self.assertEqual(len(comp2.affects), 1) for c in comp2.affects: self.assertTrue(isinstance(c, model.ComponentBase)) self.assertEqual(c.name, "MyHwComp") self.assertEqual(c.role, "affected") comp2_new = model.getObject("testscont2", "MyHwComp2") self.assertEqual(comp2_new.name, "MyHwComp2") self.assertEqual(len(comp2_new.affects), 1) comp.terminate() comp2.terminate() model.getContainer("testscont").terminate() model.getContainer("testscont2").terminate() time.sleep(0.1) # give it some time to terminate
def test_dataflow(self): cont, comp = model.createInNewContainer("testscont", MyComponent, {"name":"MyComp"}) self.assertEqual(comp.name, "MyComp") cont2, comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2.affects.value.append(comp) self.assertEqual(len(comp2.affects.value), 1) comp_indir = list(comp2.affects.value)[0] self.count = 0 self.data_arrays_sent = 0 comp_indir.data.reset() comp_indir.data.subscribe(self.receive_data) time.sleep(0.5) comp_indir.data.unsubscribe(self.receive_data) count_end = self.count print("received %d arrays over %d" % (self.count, self.data_arrays_sent)) time.sleep(0.1) self.assertEqual(count_end, self.count) comp.terminate() comp2.terminate() cont.terminate() cont2.terminate() time.sleep(0.1) # give it some time to terminate
def test_dataflow_unsub(self): """ Check the dataflow is automatically unsubscribed when the subscriber disappears. """ cont, comp = model.createInNewContainer("testscont", MyComponent, {"name": "MyComp"}) cont2, comp2 = model.createInNewContainer("testscont2", MyComponent, {"name": "MyComp2"}) self.count = 0 self.data_arrays_sent = 0 comp.data.reset() # special hidden function that will directly ask the original DF nlisteners = comp.data._count_listeners() self.assertEqual(nlisteners, 0) comp2.sub(comp.data) time.sleep(0.5) # comp2.unsub() count_arrays = comp2.get_data_count() logging.info("received %d arrays", count_arrays) nlisteners = comp.data._count_listeners() logging.info("orig has %d listeners", nlisteners) comp2.terminate() cont2.terminate() logging.info("comp2 should now be disappeared") time.sleep(0.4) nlisteners = comp.data._count_listeners() self.assertEqual(nlisteners, 0) comp.terminate() cont.terminate() time.sleep(0.1) # give it some time to terminate
def scan(): """ Scan for connected devices and list them Output like: Classname: 'Name of Device' init={arg: value, arg2: value2} """ # only here, to avoid importing everything for other commands from odemis import driver num = 0 # we scan by using every HwComponent class which has a .scan() method for module_name in driver.__all__: module = importlib.import_module("." + module_name, "odemis.driver") for cls_name, cls in inspect.getmembers(module, inspect.isclass): if issubclass(cls, model.HwComponent) and hasattr(cls, "scan"): logging.info("Scanning for %s.%s components", module_name, cls_name) # do it in a separate container so that we don't have to load # all drivers in the same process (andor cams don't like it) container_name = "scanner%d" % num num += 1 scanner = model.createInNewContainer(container_name, Scanner, {"cls": cls}) devices = scanner.scan() scanner.terminate() model.getContainer(container_name).terminate() for name, args in devices: print "%s.%s: '%s' init=%s" % (module_name, cls_name, name, str(args)) return 0
def scan(cls=None): """ Scan for connected devices and list them cls (str or None): the class name to scan (as written in the microscope file) Output like: Classname: 'Name of Device' init={arg: value, arg2: value2} """ # FIXME: need to work when /var/run/odemisd is not available: # => fail to create the container. # only here, to avoid importing everything for other commands from odemis import driver num = 0 cls_found = False # we scan by using every HwComponent class which has a .scan() method for module_name in driver.__all__: try: module = importlib.import_module("." + module_name, "odemis.driver") except ImportError: logging.warning("Cannot try module %s, failed to load." % module_name) except Exception: logging.exception("Failed to load module %s" % module_name) for cls_name, clso in inspect.getmembers(module, inspect.isclass): if issubclass(clso, model.HwComponent) and hasattr(clso, "scan"): if cls: full_name = "%s.%s" % (module_name, cls_name) if cls != full_name: logging.debug("Skipping %s", full_name) continue else: cls_found = True logging.info("Scanning for %s.%s components", module_name, cls_name) # do it in a separate container so that we don't have to load # all drivers in the same process (andor cams don't like it) container_name = "scanner%d" % num num += 1 try: cont, scanner = model.createInNewContainer( container_name, Scanner, {"cls": clso}) devices = scanner.scan() scanner.terminate() cont.terminate() except Exception: logging.exception("Failed to scan %s.%s components", module_name, cls_name) else: if not devices: logging.info("No device found") for name, args in devices: print "%s.%s: '%s' init=%s" % (module_name, cls_name, name, str(args)) if cls and not cls_found: raise ValueError("Failed to find class %s" % cls)
def test_instantiate_simple_component(self): container, comp = model.createInNewContainer("testscont", FamilyValueComponent, {"name":"MyComp"}) self.assertEqual(comp.name, "MyComp") comp_prime = model.getObject("testscont", "MyComp") self.assertEqual(comp_prime.name, "MyComp") comp.terminate() container.terminate()
def _instantiate_comp(self, name): """ Instantiate a component name (str): name that will be given to the component instance returns (HwComponent): an instance of the component Raises: SemanticError in case an error in the model is detected. """ attr = self.ast[name] class_name = attr["class"] class_comp = get_class(class_name) # create the arguments: # name (str) # role (str) # children: # * explicit creation: (dict str -> HwComponent) internal name -> comp # * delegation: (dict str -> dict) internal name -> init arguments # anything else is passed as is args = self._make_args(name) logging.debug("Going to instantiate %s (%s) with args %s", name, class_name, args) # if the component is connected to a PowerSupplier we first need to turn # it on before we instantiate it if "power_supplier" in args: f = args["power_supplier"].supply({name: True}) f.result() if self.dry_run and not class_name == "Microscope": # mock class for everything but Microscope (because it is safe) args["_realcls"] = class_comp class_comp = mock.MockComponent try: cont = self._get_container(name) if cont is None: # new container has the same name as the component cont, comp = model.createInNewContainer(name, class_comp, args) self.sub_containers[name] = cont else: logging.debug("Creating %s in container %s", name, cont) comp = model.createInContainer(cont, class_comp, args) self._comp_container[name] = cont except Exception: logging.error("Error while instantiating component %s.", name) raise self.components.add(comp) # Add all the children, which were created by delegation, to our list of components. self.components |= comp.children.value for child in comp.children.value: self._comp_container[child.name] = cont return comp
def test_va(self): cont, comp = model.createInNewContainer("testscont", SimpleHwComponent, { "name": "MyHwComp", "role": "affected" }) self.assertEqual(comp.name, "MyHwComp") cont2, comp2 = model.createInNewContainer("testscont2", model.HwComponent, { "name": "MyHwComp2", "role": "affecter" }) self.assertEqual(comp2.name, "MyHwComp2") comp2.affects.value.append(comp) self.assertEqual(len(comp2.affects.value), 1) comp_indir = comp2.affects.value[0] self.assertIsInstance(comp_indir.prop, VigilantAttributeBase) self.assertIsInstance(comp_indir.cont, VigilantAttributeBase) self.assertIsInstance(comp_indir.enum, VigilantAttributeBase) prop = comp_indir.prop self.assertEqual(prop.value, 42) prop.value += 1 self.assertEqual(prop.value, 43) self.assertEqual(comp.prop.value, 43) self.assertEqual(comp_indir.cont.value, 2.0) self.assertIsInstance(comp_indir.cont.range, tuple) try: # there is no such thing, it should fail c = len(comp_indir.cont.choices) self.fail("Accessing choices should fail") except: pass self.assertEqual(comp_indir.enum.value, "a") comp.terminate() comp2.terminate() cont.terminate() cont2.terminate()
def _instantiate_comp(self, name): """ Instantiate a component name (str): name that will be given to the component instance returns (HwComponent): an instance of the component Raises: SemanticError in case an error in the model is detected. """ attr = self.ast[name] class_name = attr["class"] class_comp = get_class(class_name) # create the arguments: # name (str) # role (str) # children: # * explicit creation: (dict str -> HwComponent) internal name -> comp # * delegation: (dict str -> dict) internal name -> init arguments # anything else is passed as is args = self._make_args(name) logging.debug("Going to instantiate %s (%s) with args %s", name, class_name, args) # if the component is connected to a PowerSupplier we first need to turn # it on before we instantiate it if "power_supplier" in args: f = args["power_supplier"].supply({name: True}) f.result() if self.dry_run and not class_name == "Microscope": # mock class for everything but Microscope (because it is safe) args["_realcls"] = class_comp class_comp = mock.MockComponent try: cont = self._get_container(name) if cont is None: # new container has the same name as the component cont, comp = model.createInNewContainer(name, class_comp, args) self.sub_containers[name] = cont else: logging.debug("Creating %s in container %s", name, cont) comp = model.createInContainer(cont, class_comp, args) self._comp_container[name] = cont except Exception: logging.error("Error while instantiating component %s.", name) raise self.components.add(comp) # Add all the children to our list of components. Useful only if child # created by delegation, but can't hurt to add them all. self.components |= comp.children.value return comp
def test_roattributes(self): cont, comp = model.createInNewContainer("testscont", MyComponent, {"name": "MyComp"}) self.assertEqual(comp.name, "MyComp") cont2, comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name": "MyHwComp2", "role": "affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2.affects.value.append(comp) self.assertEqual(len(comp2.affects.value), 1) for c in comp2.affects.value: self.assertTrue(isinstance(c, model.ComponentBase)) self.assertEqual(c.name, "MyComp") val = comp.my_value self.assertEqual(val, "ro", "Reading attribute failed") comp.terminate() comp2.terminate() cont.terminate() cont2.terminate()
def test_roattributes(self): comp = model.createInNewContainer("testscont", MyComponent, {"name":"MyComp"}) self.assertEqual(comp.name, "MyComp") comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2._set_affects(set([comp])) self.assertEqual(len(comp2.affects), 1) for c in comp2.affects: self.assertTrue(isinstance(c, model.ComponentBase)) self.assertEqual(c.name, "MyComp") val = comp.my_value self.assertEqual(val, "ro", "Reading attribute failed") comp.terminate() comp2.terminate() model.getContainer("testscont").terminate() model.getContainer("testscont2").terminate()
def scan(cls=None): """ Scan for connected devices and list them cls (str or None): the class name to scan (as written in the microscope file) Output like: Classname: 'Name of Device' init={arg: value, arg2: value2} """ # FIXME: need to work when /var/run/odemisd is not available: # => fail to create the container. # only here, to avoid importing everything for other commands from odemis import driver num = 0 cls_found = False # we scan by using every HwComponent class which has a .scan() method for module_name in driver.__all__: try: module = importlib.import_module("." + module_name, "odemis.driver") except ImportError: logging.warning("Cannot try module %s, failed to load." % module_name) except Exception: logging.exception("Failed to load module %s" % module_name) for cls_name, clso in inspect.getmembers(module, inspect.isclass): if issubclass(clso, model.HwComponent) and hasattr(clso, "scan"): if cls: full_name = "%s.%s" % (module_name, cls_name) if cls != full_name: logging.debug("Skipping %s", full_name) continue else: cls_found = True logging.info("Scanning for %s.%s components", module_name, cls_name) # do it in a separate container so that we don't have to load # all drivers in the same process (andor cams don't like it) container_name = "scanner%d" % num num += 1 try: cont, scanner = model.createInNewContainer(container_name, Scanner, {"cls": clso}) devices = scanner.scan() scanner.terminate() cont.terminate() except Exception: logging.exception("Failed to scan %s.%s components", module_name, cls_name) else: if not devices: logging.info("No device found") for name, args in devices: print "%s.%s: '%s' init=%s" % (module_name, cls_name, name, str(args)) if cls and not cls_found: raise ValueError("Failed to find class %s" % cls)
def test_instantiate_component(self): comp = model.createInNewContainer("testcont", MyComponent, {"name":"MyComp"}) self.assertEqual(comp.name, "MyComp") val = comp.my_value self.assertEqual(val, "ro", "Reading attribute failed") comp_prime = model.getObject("testcont", "MyComp") self.assertEqual(comp_prime.name, "MyComp") container = model.getContainer("testcont") container.ping() comp.terminate() container.terminate()
def _instantiate_comp(self, name): """ Instantiate a component name (str): name that will be given to the component instance returns (HwComponent): an instance of the component Raises: SemanticError in case an error in the model is detected. """ attr = self.ast[name] class_name = attr["class"] class_comp = get_class(class_name) # create the arguments: # name (str) # role (str) # children: # * explicit creation: (dict str -> HwComponent) internal name -> comp # * delegation: (dict str -> dict) internal name -> init arguments # anything else is passed as is args = self._make_args(name) logging.debug("Going to instantiate %s (%s) with args %s", name, class_name, args) if self.dry_run and not class_name == "Microscope": # mock class for everything but Microscope (because it is safe) args["_realcls"] = class_comp class_comp = mock.MockComponent try: # If it's not a leaf, it's probably a wrapper (eg, MultiplexActuator), # which is simple Python code and so doesn't need to run in a # separate container. if self.create_sub_containers and self.is_leaf(name): # new container has the same name as the component cont, comp = model.createInNewContainer(name, class_comp, args) self.sub_containers.add(cont) else: logging.debug("Creating %s in root container", name) comp = self.root_container.instantiate(class_comp, args) except Exception: logging.error("Error while instantiating component %s.", name) raise self.components.add(comp) # Add all the children to our list of components. Useful only if child # created by delegation, but can't hurt to add them all. self.components |= comp.children.value return comp
def test_multi_components(self): container, comp = model.createInNewContainer("testmulti", FatherComponent, {"name":"Father", "children_num":3}) self.assertEqual(comp.name, "Father") self.assertEqual(len(comp.children.value), 3, "Component should have 3 children") for child in comp.children.value: self.assertLess(child.value, 3) comp_direct = model.getObject("testmulti", child.name) self.assertEqual(comp_direct.name, child.name) # child.terminate() comp.terminate() # we are not terminating the children, but this should be caught by the container container.terminate()
def test_instantiate_component(self): comp = model.createInNewContainer("testcont", MyComponent, {"name": "MyComp"}) self.assertEqual(comp.name, "MyComp") val = comp.my_value self.assertEqual(val, "ro", "Reading attribute failed") comp_prime = model.getObject("testcont", "MyComp") self.assertEqual(comp_prime.name, "MyComp") container = model.getContainer("testcont") container.ping() comp.terminate() container.terminate()
def test_multi_components(self): comp = model.createInNewContainer("testmulti", FatherComponent, {"name":"Father", "children_num":3}) self.assertEqual(comp.name, "Father") self.assertEqual(len(comp.children), 3, "Component should have 3 children") for child in comp.children: self.assertLess(child.value, 3) comp_direct = model.getObject("testmulti", child.name) self.assertEqual(comp_direct.name, child.name) # child.terminate() comp.terminate() # we are not terminating the children, but this should be caught by the container model.getContainer("testmulti").terminate()
def test_va(self): comp = model.createInNewContainer("testscont", SimpleHwComponent, {"name":"MyHwComp", "role":"affected"}) self.assertEqual(comp.name, "MyHwComp") comp2 = model.createInNewContainer("testscont2", model.HwComponent, {"name":"MyHwComp2", "role":"affecter"}) self.assertEqual(comp2.name, "MyHwComp2") comp2._set_affects(set([comp])) self.assertEqual(len(comp2.affects), 1) comp_indir = list(comp2.affects)[0] self.assertIsInstance(comp_indir.prop, VigilantAttributeBase) self.assertIsInstance(comp_indir.cont, VigilantAttributeBase) self.assertIsInstance(comp_indir.enum, VigilantAttributeBase) prop = comp_indir.prop self.assertEqual(prop.value, 42) prop.value += 1 self.assertEqual(prop.value, 43) self.assertEqual(comp.prop.value, 43) self.assertEqual(comp_indir.cont.value, 2.0) self.assertIsInstance(comp_indir.cont.range, tuple) try: # there is no such thing, it should fail c = len(comp_indir.cont.choices) self.fail("Accessing choices should fail") except: pass self.assertEqual(comp_indir.enum.value, "a") comp.terminate() comp2.terminate() model.getContainer("testscont").terminate() model.getContainer("testscont2").terminate()
def instantiate_comp(self, name): """ Instantiate a component name (str): name that will be given to the component instance returns (HwComponent): an instance of the component Raises: SemanticError in case an error in the model is detected. """ attr = self.ast[name] class_name = attr["class"] class_comp = get_class(class_name) # create the arguments: # name (str) # role (str) # children: # * explicit creation: (dict str -> HwComponent) internal name -> comp # * delegation: (dict str -> dict) internal name -> init arguments # anything else is passed as is args = self.make_args(name) if self.dry_run and not class_name == "Microscope": # mock class for everything but Microscope (because it is safe) args["_realcls"] = class_comp class_comp = model.MockComponent try: if self.create_sub_containers and self.is_leaf(name): # new container has the same name as the component comp = model.createInNewContainer(name, class_comp, args) self.sub_containers.add(model.getContainer(name)) elif self.root_container: comp = self.root_container.instantiate(class_comp, args) else: comp = class_comp(**args) except Exception: logging.error("Error while instantiating component %s.", name) raise # Add all the children to our list of components. Useful only if child # created by delegation, but can't hurt to add them all. self.components |= getattr(comp, "children", set()) return comp