async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the SyncThru component.""" if discovery_info is not None: _LOGGER.info( "Discovered a new Samsung Printer at %s", discovery_info.get(CONF_HOST) ) host = discovery_info.get(CONF_HOST) name = discovery_info.get(CONF_NAME, DEFAULT_NAME) # Main device, always added else: host = config.get(CONF_RESOURCE) name = config.get(CONF_NAME) # always pass through all of the obtained information monitored = DEFAULT_MONITORED_CONDITIONS session = aiohttp_client.async_get_clientsession(hass) printer = SyncThru(host, session) # Test if the discovered device actually is a syncthru printer # and fetch the available toner/drum/etc try: # No error is thrown when the device is off # (only after user added it manually) # therefore additional catches are inside the Sensor below await printer.update() supp_toner = printer.toner_status(filter_supported=True) supp_drum = printer.drum_status(filter_supported=True) supp_tray = printer.input_tray_status(filter_supported=True) supp_output_tray = printer.output_tray_status() except ValueError: # if an exception is thrown, printer does not support syncthru # and should not be set up # If the printer was discovered automatically, no warning or error # should be issued and printer should not be set up if discovery_info is not None: _LOGGER.info("Samsung printer at %s does not support SyncThru", host) return # Otherwise, emulate printer that supports everything supp_toner = TONER_COLORS supp_drum = DRUM_COLORS supp_tray = TRAYS supp_output_tray = OUTPUT_TRAYS devices = [SyncThruMainSensor(printer, name)] for key in supp_toner: if f"toner_{key}" in monitored: devices.append(SyncThruTonerSensor(printer, name, key)) for key in supp_drum: if f"drum_{key}" in monitored: devices.append(SyncThruDrumSensor(printer, name, key)) for key in supp_tray: if f"tray_{key}" in monitored: devices.append(SyncThruInputTraySensor(printer, name, key)) for key in supp_output_tray: if f"output_tray_{key}" in monitored: devices.append(SyncThruOutputTraySensor(printer, name, key)) async_add_entities(devices, True)
def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the SyncThru component.""" from pysyncthru import SyncThru, test_syncthru if discovery_info is not None: host = discovery_info.get(CONF_HOST) name = discovery_info.get(CONF_NAME, DEFAULT_NAME) _LOGGER.debug("Discovered a new Samsung Printer: %s", discovery_info) # Test if the discovered device actually is a syncthru printer if not test_syncthru(host): _LOGGER.error("No SyncThru Printer found at %s", host) return monitored = DEFAULT_MONITORED_CONDITIONS else: host = config.get(CONF_RESOURCE) name = config.get(CONF_NAME) monitored = config.get(CONF_MONITORED_CONDITIONS) # Main device, always added try: printer = SyncThru(host) except TypeError: # if an exception is thrown, printer cannot be set up return printer.update() devices = [SyncThruMainSensor(printer, name)] for key in printer.toner_status(filter_supported=True): if 'toner_{}'.format(key) in monitored: devices.append(SyncThruTonerSensor(printer, name, key)) for key in printer.drum_status(filter_supported=True): if 'drum_{}'.format(key) in monitored: devices.append(SyncThruDrumSensor(printer, name, key)) for key in printer.input_tray_status(filter_supported=True): if 'tray_{}'.format(key) in monitored: devices.append(SyncThruInputTraySensor(printer, name, key)) for key in printer.output_tray_status(): if 'output_tray_{}'.format(key) in monitored: devices.append(SyncThruOutputTraySensor(printer, name, key)) add_devices(devices, True)
def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the SyncThru component.""" from pysyncthru import SyncThru, test_syncthru if discovery_info is not None: host = discovery_info.get(CONF_HOST) name = discovery_info.get(CONF_NAME, DEFAULT_NAME) _LOGGER.debug("Discovered a new Samsung Printer: %s", discovery_info) # Test if the discovered device actually is a syncthru printer if not test_syncthru(host): _LOGGER.error("No SyncThru Printer found at %s", host) return monitored = DEFAULT_MONITORED_CONDITIONS else: host = config.get(CONF_RESOURCE) name = config.get(CONF_NAME) monitored = config.get(CONF_MONITORED_CONDITIONS) # Main device, always added try: printer = SyncThru(host) except TypeError: # if an exception is thrown, printer cannot be set up return printer.update() devices = [SyncThruMainSensor(printer, name)] for key in printer.toner_status(filter_supported=True): if 'toner_{}'.format(key) in monitored: devices.append(SyncThruTonerSensor(printer, name, key)) for key in printer.drum_status(filter_supported=True): if 'drum_{}'.format(key) in monitored: devices.append(SyncThruDrumSensor(printer, name, key)) for key in printer.input_tray_status(filter_supported=True): if 'tray_{}'.format(key) in monitored: devices.append(SyncThruInputTraySensor(printer, name, key)) for key in printer.output_tray_status(): if 'output_tray_{}'.format(key) in monitored: devices.append(SyncThruOutputTraySensor(printer, name, key)) add_entities(devices, True)
async def async_setup_entry(hass, config_entry, async_add_entities): """Set up from config entry.""" session = aiohttp_client.async_get_clientsession(hass) printer = SyncThru(config_entry.data[CONF_URL], session) # Test if the discovered device actually is a syncthru printer # and fetch the available toner/drum/etc try: # No error is thrown when the device is off # (only after user added it manually) # therefore additional catches are inside the Sensor below await printer.update() supp_toner = printer.toner_status(filter_supported=True) supp_drum = printer.drum_status(filter_supported=True) supp_tray = printer.input_tray_status(filter_supported=True) supp_output_tray = printer.output_tray_status() except ValueError as ex: raise SyncThruNotSupported from ex else: if printer.is_unknown_state(): raise PlatformNotReady name = config_entry.data[CONF_NAME] devices = [SyncThruMainSensor(printer, name)] for key in supp_toner: devices.append(SyncThruTonerSensor(printer, name, key)) for key in supp_drum: devices.append(SyncThruDrumSensor(printer, name, key)) for key in supp_tray: devices.append(SyncThruInputTraySensor(printer, name, key)) for key in supp_output_tray: devices.append(SyncThruOutputTraySensor(printer, name, key)) async_add_entities(devices, True)
class SyncthruAPITest(unittest.TestCase): server = None server_control = None # type: Server port = 0 url = "http://localhost:80" syncthru = None # type: SyncThru def setUp(self) -> None: # Create an arbitrary subclass of TCP Server as the server to be started # Here, it is an Simple HTTP file serving server handler = SyncThruRequestHandler max_retries = 10 r = 0 while not self.server: try: # Connect to any open port self.server = SyncThruServer((ADDRESS, 0), handler) except OSError: if r < max_retries: r += 1 else: raise time.sleep(1) self.server_control = Server(self.server) self.port = self.server_control.get_port() self.url = "{}:{}".format(ADDRESS, self.port) # Start test server before running any tests self.server_control.start_server() async def fetch(): async with aiohttp.ClientSession() as session: self.syncthru = SyncThru( self.url, session, connection_mode=ConnectionMode.API ) await self.syncthru.update() loop = asyncio.get_event_loop() loop.run_until_complete(fetch()) def test_online(self) -> None: self.assertTrue(self.syncthru.is_online()) def test_status_normal(self) -> None: self.assertEqual(self.syncthru.device_status(), SyncthruState.NORMAL) def test_status_details(self) -> None: self.assertEqual(self.syncthru.device_status_details(), "Sleeping...") def test_model(self) -> None: self.assertEqual(self.syncthru.model(), RAW["identity"]["model_name"]) def test_toner_filter(self) -> None: self.assertDictEqual( self.syncthru.toner_status(True), {"black": {"opt": 1, "remaining": 58, "cnt": 229, "newError": ""}}, ) def test_toner_no_filter(self) -> None: empty = {"opt": 0, "remaining": 0, "cnt": 0, "newError": ""} self.assertDictEqual( self.syncthru.toner_status(False), { "yellow": empty, "magenta": empty, "cyan": empty, "black": {"opt": 1, "remaining": 58, "cnt": 229, "newError": ""}, }, ) def test_input_tray_filter(self) -> None: self.assertDictEqual( self.syncthru.input_tray_status(True), { "tray_1": { "capa": 150, "newError": "", "opt": 1, "paper_size1": 4, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, } }, ) def test_input_tray_no_filter(self) -> None: self.assertDictEqual( self.syncthru.input_tray_status(False), { "tray_1": { "capa": 150, "newError": "", "opt": 1, "paper_size1": 4, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, }, "tray_2": { "capa": 0, "newError": "", "opt": 0, "paper_size1": 0, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, }, "tray_3": { "capa": 0, "newError": "", "opt": 0, "paper_size1": 0, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, }, "tray_4": { "capa": 0, "newError": "", "opt": 2, "paper_size1": 0, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, }, "tray_5": { "opt": 0, "paper_size1": 0, "paper_size2": 0, "paper_type1": 0, "paper_type2": 0, "capa": 0, "newError": "0", }, "mp": { "opt": 0, "paper_size1": 0, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, "capa": 0, "newError": "", }, "manual": { "opt": 0, "paper_size1": 0, "paper_size2": 0, "paper_type1": 2, "paper_type2": 0, "capa": 0, "newError": "", }, }, ) def test_output_tray(self) -> None: self.assertEqual( self.syncthru.output_tray_status(), {0: {"capacity": 100, "name": 1, "status": ""}}, ) def test_drum_status_filter(self) -> None: self.assertEqual(self.syncthru.drum_status(True), {}) def test_drum_status_no_filter(self) -> None: self.assertEqual( self.syncthru.drum_status(False), { "black": {"newError": "", "opt": 0, "remaining": 0}, "cyan": {"newError": "", "opt": 0, "remaining": 100}, "magenta": {"newError": "", "opt": 0, "remaining": 100}, "yellow": {"newError": "", "opt": 0, "remaining": 100}, }, ) def test_location(self) -> None: self.assertEqual(self.syncthru.location(), RAW["identity"]["location"]) def test_serial_number(self) -> None: self.assertEqual(self.syncthru.serial_number(), RAW["identity"]["serial_num"]) def test_hostname(self) -> None: self.assertEqual(self.syncthru.hostname(), RAW["identity"]["host_name"]) def test_cap(self) -> None: self.assertEqual(self.syncthru.capability(), RAW["capability"]) def tearDown(self) -> None: self.server_control.stop_server()