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()
