Search is not available for this dataset
identifier
stringlengths 1
155
| parameters
stringlengths 2
6.09k
| docstring
stringlengths 11
63.4k
| docstring_summary
stringlengths 0
63.4k
| function
stringlengths 29
99.8k
| function_tokens
sequence | start_point
sequence | end_point
sequence | language
stringclasses 1
value | docstring_language
stringlengths 2
7
| docstring_language_predictions
stringlengths 18
23
| is_langid_reliable
stringclasses 2
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
async_setup_entry | (hass, entry, async_add_entities) | Set up SimpliSafe locks based on a config entry. | Set up SimpliSafe locks based on a config entry. | async def async_setup_entry(hass, entry, async_add_entities):
"""Set up SimpliSafe locks based on a config entry."""
simplisafe = hass.data[DOMAIN][DATA_CLIENT][entry.entry_id]
async_add_entities(
[
SimpliSafeLock(simplisafe, system, lock)
for system in simplisafe.systems.values()
for lock in system.locks.values()
]
) | [
"async",
"def",
"async_setup_entry",
"(",
"hass",
",",
"entry",
",",
"async_add_entities",
")",
":",
"simplisafe",
"=",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"[",
"DATA_CLIENT",
"]",
"[",
"entry",
".",
"entry_id",
"]",
"async_add_entities",
"(",
"[",
"SimpliSafeLock",
"(",
"simplisafe",
",",
"system",
",",
"lock",
")",
"for",
"system",
"in",
"simplisafe",
".",
"systems",
".",
"values",
"(",
")",
"for",
"lock",
"in",
"system",
".",
"locks",
".",
"values",
"(",
")",
"]",
")"
] | [
16,
0
] | [
25,
5
] | python | en | ['en', 'da', 'en'] | True |
SimpliSafeLock.__init__ | (self, simplisafe, system, lock) | Initialize. | Initialize. | def __init__(self, simplisafe, system, lock):
"""Initialize."""
super().__init__(simplisafe, system, lock.name, serial=lock.serial)
self._lock = lock
self._is_locked = None
for event_type in (EVENT_LOCK_LOCKED, EVENT_LOCK_UNLOCKED):
self.websocket_events_to_listen_for.append(event_type) | [
"def",
"__init__",
"(",
"self",
",",
"simplisafe",
",",
"system",
",",
"lock",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"simplisafe",
",",
"system",
",",
"lock",
".",
"name",
",",
"serial",
"=",
"lock",
".",
"serial",
")",
"self",
".",
"_lock",
"=",
"lock",
"self",
".",
"_is_locked",
"=",
"None",
"for",
"event_type",
"in",
"(",
"EVENT_LOCK_LOCKED",
",",
"EVENT_LOCK_UNLOCKED",
")",
":",
"self",
".",
"websocket_events_to_listen_for",
".",
"append",
"(",
"event_type",
")"
] | [
31,
4
] | [
38,
66
] | python | en | ['en', 'en', 'it'] | False |
SimpliSafeLock.is_locked | (self) | Return true if the lock is locked. | Return true if the lock is locked. | def is_locked(self):
"""Return true if the lock is locked."""
return self._is_locked | [
"def",
"is_locked",
"(",
"self",
")",
":",
"return",
"self",
".",
"_is_locked"
] | [
41,
4
] | [
43,
30
] | python | en | ['en', 'mt', 'en'] | True |
SimpliSafeLock.async_lock | (self, **kwargs) | Lock the lock. | Lock the lock. | async def async_lock(self, **kwargs):
"""Lock the lock."""
try:
await self._lock.lock()
except SimplipyError as err:
LOGGER.error('Error while locking "%s": %s', self._lock.name, err)
return | [
"async",
"def",
"async_lock",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"await",
"self",
".",
"_lock",
".",
"lock",
"(",
")",
"except",
"SimplipyError",
"as",
"err",
":",
"LOGGER",
".",
"error",
"(",
"'Error while locking \"%s\": %s'",
",",
"self",
".",
"_lock",
".",
"name",
",",
"err",
")",
"return"
] | [
45,
4
] | [
51,
18
] | python | en | ['en', 'la', 'en'] | True |
SimpliSafeLock.async_unlock | (self, **kwargs) | Unlock the lock. | Unlock the lock. | async def async_unlock(self, **kwargs):
"""Unlock the lock."""
try:
await self._lock.unlock()
except SimplipyError as err:
LOGGER.error('Error while unlocking "%s": %s', self._lock.name, err)
return | [
"async",
"def",
"async_unlock",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"await",
"self",
".",
"_lock",
".",
"unlock",
"(",
")",
"except",
"SimplipyError",
"as",
"err",
":",
"LOGGER",
".",
"error",
"(",
"'Error while unlocking \"%s\": %s'",
",",
"self",
".",
"_lock",
".",
"name",
",",
"err",
")",
"return"
] | [
53,
4
] | [
59,
18
] | python | en | ['en', 'ms', 'en'] | True |
SimpliSafeLock.async_update_from_rest_api | (self) | Update the entity with the provided REST API data. | Update the entity with the provided REST API data. | def async_update_from_rest_api(self):
"""Update the entity with the provided REST API data."""
self._attrs.update(
{
ATTR_LOCK_LOW_BATTERY: self._lock.lock_low_battery,
ATTR_JAMMED: self._lock.state == LockStates.jammed,
ATTR_PIN_PAD_LOW_BATTERY: self._lock.pin_pad_low_battery,
}
)
self._is_locked = self._lock.state == LockStates.locked | [
"def",
"async_update_from_rest_api",
"(",
"self",
")",
":",
"self",
".",
"_attrs",
".",
"update",
"(",
"{",
"ATTR_LOCK_LOW_BATTERY",
":",
"self",
".",
"_lock",
".",
"lock_low_battery",
",",
"ATTR_JAMMED",
":",
"self",
".",
"_lock",
".",
"state",
"==",
"LockStates",
".",
"jammed",
",",
"ATTR_PIN_PAD_LOW_BATTERY",
":",
"self",
".",
"_lock",
".",
"pin_pad_low_battery",
",",
"}",
")",
"self",
".",
"_is_locked",
"=",
"self",
".",
"_lock",
".",
"state",
"==",
"LockStates",
".",
"locked"
] | [
62,
4
] | [
72,
63
] | python | en | ['en', 'en', 'en'] | True |
SimpliSafeLock.async_update_from_websocket_event | (self, event) | Update the entity with the provided websocket event data. | Update the entity with the provided websocket event data. | def async_update_from_websocket_event(self, event):
"""Update the entity with the provided websocket event data."""
if event.event_type == EVENT_LOCK_LOCKED:
self._is_locked = True
else:
self._is_locked = False | [
"def",
"async_update_from_websocket_event",
"(",
"self",
",",
"event",
")",
":",
"if",
"event",
".",
"event_type",
"==",
"EVENT_LOCK_LOCKED",
":",
"self",
".",
"_is_locked",
"=",
"True",
"else",
":",
"self",
".",
"_is_locked",
"=",
"False"
] | [
75,
4
] | [
80,
35
] | python | en | ['en', 'en', 'en'] | True |
async_setup | (hass: HomeAssistant, config: dict) | Set up the wiffi component. config contains data from configuration.yaml. | Set up the wiffi component. config contains data from configuration.yaml. | async def async_setup(hass: HomeAssistant, config: dict):
"""Set up the wiffi component. config contains data from configuration.yaml."""
return True | [
"async",
"def",
"async_setup",
"(",
"hass",
":",
"HomeAssistant",
",",
"config",
":",
"dict",
")",
":",
"return",
"True"
] | [
35,
0
] | [
37,
15
] | python | en | ['en', 'en', 'en'] | True |
async_setup_entry | (hass: HomeAssistant, config_entry: ConfigEntry) | Set up wiffi from a config entry, config_entry contains data from config entry database. | Set up wiffi from a config entry, config_entry contains data from config entry database. | async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry):
"""Set up wiffi from a config entry, config_entry contains data from config entry database."""
if not config_entry.update_listeners:
config_entry.add_update_listener(async_update_options)
# create api object
api = WiffiIntegrationApi(hass)
api.async_setup(config_entry)
# store api object
hass.data.setdefault(DOMAIN, {})[config_entry.entry_id] = api
try:
await api.server.start_server()
except OSError as exc:
if exc.errno != errno.EADDRINUSE:
_LOGGER.error("Start_server failed, errno: %d", exc.errno)
return False
_LOGGER.error("Port %s already in use", config_entry.data[CONF_PORT])
raise ConfigEntryNotReady from exc
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, component)
)
return True | [
"async",
"def",
"async_setup_entry",
"(",
"hass",
":",
"HomeAssistant",
",",
"config_entry",
":",
"ConfigEntry",
")",
":",
"if",
"not",
"config_entry",
".",
"update_listeners",
":",
"config_entry",
".",
"add_update_listener",
"(",
"async_update_options",
")",
"# create api object",
"api",
"=",
"WiffiIntegrationApi",
"(",
"hass",
")",
"api",
".",
"async_setup",
"(",
"config_entry",
")",
"# store api object",
"hass",
".",
"data",
".",
"setdefault",
"(",
"DOMAIN",
",",
"{",
"}",
")",
"[",
"config_entry",
".",
"entry_id",
"]",
"=",
"api",
"try",
":",
"await",
"api",
".",
"server",
".",
"start_server",
"(",
")",
"except",
"OSError",
"as",
"exc",
":",
"if",
"exc",
".",
"errno",
"!=",
"errno",
".",
"EADDRINUSE",
":",
"_LOGGER",
".",
"error",
"(",
"\"Start_server failed, errno: %d\"",
",",
"exc",
".",
"errno",
")",
"return",
"False",
"_LOGGER",
".",
"error",
"(",
"\"Port %s already in use\"",
",",
"config_entry",
".",
"data",
"[",
"CONF_PORT",
"]",
")",
"raise",
"ConfigEntryNotReady",
"from",
"exc",
"for",
"component",
"in",
"PLATFORMS",
":",
"hass",
".",
"async_create_task",
"(",
"hass",
".",
"config_entries",
".",
"async_forward_entry_setup",
"(",
"config_entry",
",",
"component",
")",
")",
"return",
"True"
] | [
40,
0
] | [
66,
15
] | python | en | ['en', 'en', 'en'] | True |
async_update_options | (hass: HomeAssistant, config_entry: ConfigEntry) | Update options. | Update options. | async def async_update_options(hass: HomeAssistant, config_entry: ConfigEntry):
"""Update options."""
await hass.config_entries.async_reload(config_entry.entry_id) | [
"async",
"def",
"async_update_options",
"(",
"hass",
":",
"HomeAssistant",
",",
"config_entry",
":",
"ConfigEntry",
")",
":",
"await",
"hass",
".",
"config_entries",
".",
"async_reload",
"(",
"config_entry",
".",
"entry_id",
")"
] | [
69,
0
] | [
71,
65
] | python | en | ['en', 'en', 'en'] | False |
async_unload_entry | (hass: HomeAssistant, config_entry: ConfigEntry) | Unload a config entry. | Unload a config entry. | async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry):
"""Unload a config entry."""
api: "WiffiIntegrationApi" = hass.data[DOMAIN][config_entry.entry_id]
await api.server.close_server()
unload_ok = all(
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(config_entry, component)
for component in PLATFORMS
]
)
)
if unload_ok:
api = hass.data[DOMAIN].pop(config_entry.entry_id)
api.shutdown()
return unload_ok | [
"async",
"def",
"async_unload_entry",
"(",
"hass",
":",
"HomeAssistant",
",",
"config_entry",
":",
"ConfigEntry",
")",
":",
"api",
":",
"\"WiffiIntegrationApi\"",
"=",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"[",
"config_entry",
".",
"entry_id",
"]",
"await",
"api",
".",
"server",
".",
"close_server",
"(",
")",
"unload_ok",
"=",
"all",
"(",
"await",
"asyncio",
".",
"gather",
"(",
"*",
"[",
"hass",
".",
"config_entries",
".",
"async_forward_entry_unload",
"(",
"config_entry",
",",
"component",
")",
"for",
"component",
"in",
"PLATFORMS",
"]",
")",
")",
"if",
"unload_ok",
":",
"api",
"=",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
".",
"pop",
"(",
"config_entry",
".",
"entry_id",
")",
"api",
".",
"shutdown",
"(",
")",
"return",
"unload_ok"
] | [
74,
0
] | [
91,
20
] | python | en | ['en', 'es', 'en'] | True |
generate_unique_id | (device, metric) | Generate a unique string for the entity. | Generate a unique string for the entity. | def generate_unique_id(device, metric):
"""Generate a unique string for the entity."""
return f"{device.mac_address.replace(':', '')}-{metric.name}" | [
"def",
"generate_unique_id",
"(",
"device",
",",
"metric",
")",
":",
"return",
"f\"{device.mac_address.replace(':', '')}-{metric.name}\""
] | [
94,
0
] | [
96,
65
] | python | en | ['en', 'en', 'en'] | True |
WiffiIntegrationApi.__init__ | (self, hass) | Initialize the instance. | Initialize the instance. | def __init__(self, hass):
"""Initialize the instance."""
self._hass = hass
self._server = None
self._known_devices = {}
self._periodic_callback = None | [
"def",
"__init__",
"(",
"self",
",",
"hass",
")",
":",
"self",
".",
"_hass",
"=",
"hass",
"self",
".",
"_server",
"=",
"None",
"self",
".",
"_known_devices",
"=",
"{",
"}",
"self",
".",
"_periodic_callback",
"=",
"None"
] | [
102,
4
] | [
107,
38
] | python | en | ['en', 'en', 'en'] | True |
WiffiIntegrationApi.async_setup | (self, config_entry) | Set up api instance. | Set up api instance. | def async_setup(self, config_entry):
"""Set up api instance."""
self._server = WiffiTcpServer(config_entry.data[CONF_PORT], self)
self._periodic_callback = async_track_time_interval(
self._hass, self._periodic_tick, timedelta(seconds=10)
) | [
"def",
"async_setup",
"(",
"self",
",",
"config_entry",
")",
":",
"self",
".",
"_server",
"=",
"WiffiTcpServer",
"(",
"config_entry",
".",
"data",
"[",
"CONF_PORT",
"]",
",",
"self",
")",
"self",
".",
"_periodic_callback",
"=",
"async_track_time_interval",
"(",
"self",
".",
"_hass",
",",
"self",
".",
"_periodic_tick",
",",
"timedelta",
"(",
"seconds",
"=",
"10",
")",
")"
] | [
109,
4
] | [
114,
9
] | python | en | ['en', 'pt', 'en'] | True |
WiffiIntegrationApi.shutdown | (self) | Shutdown wiffi api.
Remove listener for periodic callbacks.
| Shutdown wiffi api. | def shutdown(self):
"""Shutdown wiffi api.
Remove listener for periodic callbacks.
"""
remove_listener = self._periodic_callback
if remove_listener is not None:
remove_listener() | [
"def",
"shutdown",
"(",
"self",
")",
":",
"remove_listener",
"=",
"self",
".",
"_periodic_callback",
"if",
"remove_listener",
"is",
"not",
"None",
":",
"remove_listener",
"(",
")"
] | [
116,
4
] | [
123,
29
] | python | en | ['en', 'ja-Latn', 'sw'] | False |
WiffiIntegrationApi.__call__ | (self, device, metrics) | Process callback from TCP server if new data arrives from a device. | Process callback from TCP server if new data arrives from a device. | async def __call__(self, device, metrics):
"""Process callback from TCP server if new data arrives from a device."""
if device.mac_address not in self._known_devices:
# add empty set for new device
self._known_devices[device.mac_address] = set()
for metric in metrics:
if metric.id not in self._known_devices[device.mac_address]:
self._known_devices[device.mac_address].add(metric.id)
async_dispatcher_send(self._hass, CREATE_ENTITY_SIGNAL, device, metric)
else:
async_dispatcher_send(
self._hass,
f"{UPDATE_ENTITY_SIGNAL}-{generate_unique_id(device, metric)}",
device,
metric,
) | [
"async",
"def",
"__call__",
"(",
"self",
",",
"device",
",",
"metrics",
")",
":",
"if",
"device",
".",
"mac_address",
"not",
"in",
"self",
".",
"_known_devices",
":",
"# add empty set for new device",
"self",
".",
"_known_devices",
"[",
"device",
".",
"mac_address",
"]",
"=",
"set",
"(",
")",
"for",
"metric",
"in",
"metrics",
":",
"if",
"metric",
".",
"id",
"not",
"in",
"self",
".",
"_known_devices",
"[",
"device",
".",
"mac_address",
"]",
":",
"self",
".",
"_known_devices",
"[",
"device",
".",
"mac_address",
"]",
".",
"add",
"(",
"metric",
".",
"id",
")",
"async_dispatcher_send",
"(",
"self",
".",
"_hass",
",",
"CREATE_ENTITY_SIGNAL",
",",
"device",
",",
"metric",
")",
"else",
":",
"async_dispatcher_send",
"(",
"self",
".",
"_hass",
",",
"f\"{UPDATE_ENTITY_SIGNAL}-{generate_unique_id(device, metric)}\"",
",",
"device",
",",
"metric",
",",
")"
] | [
125,
4
] | [
141,
17
] | python | en | ['en', 'en', 'en'] | True |
WiffiIntegrationApi.server | (self) | Return TCP server instance for start + close. | Return TCP server instance for start + close. | def server(self):
"""Return TCP server instance for start + close."""
return self._server | [
"def",
"server",
"(",
"self",
")",
":",
"return",
"self",
".",
"_server"
] | [
144,
4
] | [
146,
27
] | python | en | ['en', 'no', 'en'] | True |
WiffiIntegrationApi._periodic_tick | (self, now=None) | Check if any entity has timed out because it has not been updated. | Check if any entity has timed out because it has not been updated. | def _periodic_tick(self, now=None):
"""Check if any entity has timed out because it has not been updated."""
async_dispatcher_send(self._hass, CHECK_ENTITIES_SIGNAL) | [
"def",
"_periodic_tick",
"(",
"self",
",",
"now",
"=",
"None",
")",
":",
"async_dispatcher_send",
"(",
"self",
".",
"_hass",
",",
"CHECK_ENTITIES_SIGNAL",
")"
] | [
149,
4
] | [
151,
64
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.__init__ | (self, device, metric, options) | Initialize the base elements of a wiffi entity. | Initialize the base elements of a wiffi entity. | def __init__(self, device, metric, options):
"""Initialize the base elements of a wiffi entity."""
self._id = generate_unique_id(device, metric)
self._device_info = {
"connections": {
(device_registry.CONNECTION_NETWORK_MAC, device.mac_address)
},
"identifiers": {(DOMAIN, device.mac_address)},
"manufacturer": "stall.biz",
"name": f"{device.moduletype} {device.mac_address}",
"model": device.moduletype,
"sw_version": device.sw_version,
}
self._name = metric.description
self._expiration_date = None
self._value = None
self._timeout = options.get(CONF_TIMEOUT, DEFAULT_TIMEOUT) | [
"def",
"__init__",
"(",
"self",
",",
"device",
",",
"metric",
",",
"options",
")",
":",
"self",
".",
"_id",
"=",
"generate_unique_id",
"(",
"device",
",",
"metric",
")",
"self",
".",
"_device_info",
"=",
"{",
"\"connections\"",
":",
"{",
"(",
"device_registry",
".",
"CONNECTION_NETWORK_MAC",
",",
"device",
".",
"mac_address",
")",
"}",
",",
"\"identifiers\"",
":",
"{",
"(",
"DOMAIN",
",",
"device",
".",
"mac_address",
")",
"}",
",",
"\"manufacturer\"",
":",
"\"stall.biz\"",
",",
"\"name\"",
":",
"f\"{device.moduletype} {device.mac_address}\"",
",",
"\"model\"",
":",
"device",
".",
"moduletype",
",",
"\"sw_version\"",
":",
"device",
".",
"sw_version",
",",
"}",
"self",
".",
"_name",
"=",
"metric",
".",
"description",
"self",
".",
"_expiration_date",
"=",
"None",
"self",
".",
"_value",
"=",
"None",
"self",
".",
"_timeout",
"=",
"options",
".",
"get",
"(",
"CONF_TIMEOUT",
",",
"DEFAULT_TIMEOUT",
")"
] | [
157,
4
] | [
173,
66
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.async_added_to_hass | (self) | Entity has been added to hass. | Entity has been added to hass. | async def async_added_to_hass(self):
"""Entity has been added to hass."""
self.async_on_remove(
async_dispatcher_connect(
self.hass,
f"{UPDATE_ENTITY_SIGNAL}-{self._id}",
self._update_value_callback,
)
)
self.async_on_remove(
async_dispatcher_connect(
self.hass, CHECK_ENTITIES_SIGNAL, self._check_expiration_date
)
) | [
"async",
"def",
"async_added_to_hass",
"(",
"self",
")",
":",
"self",
".",
"async_on_remove",
"(",
"async_dispatcher_connect",
"(",
"self",
".",
"hass",
",",
"f\"{UPDATE_ENTITY_SIGNAL}-{self._id}\"",
",",
"self",
".",
"_update_value_callback",
",",
")",
")",
"self",
".",
"async_on_remove",
"(",
"async_dispatcher_connect",
"(",
"self",
".",
"hass",
",",
"CHECK_ENTITIES_SIGNAL",
",",
"self",
".",
"_check_expiration_date",
")",
")"
] | [
175,
4
] | [
188,
9
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.should_poll | (self) | Disable polling because data driven . | Disable polling because data driven . | def should_poll(self):
"""Disable polling because data driven ."""
return False | [
"def",
"should_poll",
"(",
"self",
")",
":",
"return",
"False"
] | [
191,
4
] | [
193,
20
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.device_info | (self) | Return wiffi device info which is shared between all entities of a device. | Return wiffi device info which is shared between all entities of a device. | def device_info(self):
"""Return wiffi device info which is shared between all entities of a device."""
return self._device_info | [
"def",
"device_info",
"(",
"self",
")",
":",
"return",
"self",
".",
"_device_info"
] | [
196,
4
] | [
198,
32
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.unique_id | (self) | Return unique id for entity. | Return unique id for entity. | def unique_id(self):
"""Return unique id for entity."""
return self._id | [
"def",
"unique_id",
"(",
"self",
")",
":",
"return",
"self",
".",
"_id"
] | [
201,
4
] | [
203,
23
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity.name | (self) | Return entity name. | Return entity name. | def name(self):
"""Return entity name."""
return self._name | [
"def",
"name",
"(",
"self",
")",
":",
"return",
"self",
".",
"_name"
] | [
206,
4
] | [
208,
25
] | python | en | ['en', 'ig', 'en'] | True |
WiffiEntity.available | (self) | Return true if value is valid. | Return true if value is valid. | def available(self):
"""Return true if value is valid."""
return self._value is not None | [
"def",
"available",
"(",
"self",
")",
":",
"return",
"self",
".",
"_value",
"is",
"not",
"None"
] | [
211,
4
] | [
213,
38
] | python | en | ['en', 'et', 'en'] | True |
WiffiEntity.reset_expiration_date | (self) | Reset value expiration date.
Will be called by derived classes after a value update has been received.
| Reset value expiration date. | def reset_expiration_date(self):
"""Reset value expiration date.
Will be called by derived classes after a value update has been received.
"""
self._expiration_date = utcnow() + timedelta(minutes=self._timeout) | [
"def",
"reset_expiration_date",
"(",
"self",
")",
":",
"self",
".",
"_expiration_date",
"=",
"utcnow",
"(",
")",
"+",
"timedelta",
"(",
"minutes",
"=",
"self",
".",
"_timeout",
")"
] | [
215,
4
] | [
220,
75
] | python | en | ['fr', 'en', 'en'] | True |
WiffiEntity._update_value_callback | (self, device, metric) | Update the value of the entity. | Update the value of the entity. | def _update_value_callback(self, device, metric):
"""Update the value of the entity.""" | [
"def",
"_update_value_callback",
"(",
"self",
",",
"device",
",",
"metric",
")",
":"
] | [
223,
4
] | [
224,
45
] | python | en | ['en', 'en', 'en'] | True |
WiffiEntity._check_expiration_date | (self) | Periodically check if entity value has been updated.
If there are no more updates from the wiffi device, the value will be
set to unavailable.
| Periodically check if entity value has been updated. | def _check_expiration_date(self):
"""Periodically check if entity value has been updated.
If there are no more updates from the wiffi device, the value will be
set to unavailable.
"""
if (
self._value is not None
and self._expiration_date is not None
and utcnow() > self._expiration_date
):
self._value = None
self.async_write_ha_state() | [
"def",
"_check_expiration_date",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"_value",
"is",
"not",
"None",
"and",
"self",
".",
"_expiration_date",
"is",
"not",
"None",
"and",
"utcnow",
"(",
")",
">",
"self",
".",
"_expiration_date",
")",
":",
"self",
".",
"_value",
"=",
"None",
"self",
".",
"async_write_ha_state",
"(",
")"
] | [
227,
4
] | [
239,
39
] | python | en | ['en', 'en', 'en'] | True |
GreedyPolicy.__init__ | (self, supply_top_k: int = 1, demand_top_k: int = 1) |
Agent that executes a greedy policy. If the event type is supply, send as many bikes as possible to one of the
demand_k stations with the most empty slots. If the event type is demand, request as many bikes as possible from
one of the supply_k stations with the most bikes.
Args:
supply_top_k (int): number of top supply candidates to choose from.
demand_top_k (int): number of top demand candidates to choose from.
|
Agent that executes a greedy policy. If the event type is supply, send as many bikes as possible to one of the
demand_k stations with the most empty slots. If the event type is demand, request as many bikes as possible from
one of the supply_k stations with the most bikes. | def __init__(self, supply_top_k: int = 1, demand_top_k: int = 1):
"""
Agent that executes a greedy policy. If the event type is supply, send as many bikes as possible to one of the
demand_k stations with the most empty slots. If the event type is demand, request as many bikes as possible from
one of the supply_k stations with the most bikes.
Args:
supply_top_k (int): number of top supply candidates to choose from.
demand_top_k (int): number of top demand candidates to choose from.
"""
self._supply_top_k = supply_top_k
self._demand_top_k = demand_top_k | [
"def",
"__init__",
"(",
"self",
",",
"supply_top_k",
":",
"int",
"=",
"1",
",",
"demand_top_k",
":",
"int",
"=",
"1",
")",
":",
"self",
".",
"_supply_top_k",
"=",
"supply_top_k",
"self",
".",
"_demand_top_k",
"=",
"demand_top_k"
] | [
18,
4
] | [
29,
41
] | python | en | ['en', 'error', 'th'] | False |
floats_list | (shape, scale=1.0, rng=None, name=None) | Creates a random float32 tensor | Creates a random float32 tensor | def floats_list(shape, scale=1.0, rng=None, name=None):
"""Creates a random float32 tensor"""
if rng is None:
rng = global_rng
values = []
for batch_idx in range(shape[0]):
values.append([])
for _ in range(shape[1]):
values[-1].append(rng.random() * scale)
return values | [
"def",
"floats_list",
"(",
"shape",
",",
"scale",
"=",
"1.0",
",",
"rng",
"=",
"None",
",",
"name",
"=",
"None",
")",
":",
"if",
"rng",
"is",
"None",
":",
"rng",
"=",
"global_rng",
"values",
"=",
"[",
"]",
"for",
"batch_idx",
"in",
"range",
"(",
"shape",
"[",
"0",
"]",
")",
":",
"values",
".",
"append",
"(",
"[",
"]",
")",
"for",
"_",
"in",
"range",
"(",
"shape",
"[",
"1",
"]",
")",
":",
"values",
"[",
"-",
"1",
"]",
".",
"append",
"(",
"rng",
".",
"random",
"(",
")",
"*",
"scale",
")",
"return",
"values"
] | [
40,
0
] | [
51,
17
] | python | en | ['en', 'ca', 'en'] | True |
is_valid_proxy | (data) |
is data is valid proxy format
:param data:
:return:
|
is data is valid proxy format
:param data:
:return:
| def is_valid_proxy(data):
"""
is data is valid proxy format
:param data:
:return:
"""
return re.match('\d+\.\d+\.\d+\.\d+\:\d+', data) | [
"def",
"is_valid_proxy",
"(",
"data",
")",
":",
"return",
"re",
".",
"match",
"(",
"'\\d+\\.\\d+\\.\\d+\\.\\d+\\:\\d+'",
",",
"data",
")"
] | [
4,
0
] | [
10,
52
] | python | en | ['en', 'error', 'th'] | False |
convert_proxy_or_proxies | (data) |
convert list of str to valid proxies or proxy
:param data:
:return:
|
convert list of str to valid proxies or proxy
:param data:
:return:
| def convert_proxy_or_proxies(data):
"""
convert list of str to valid proxies or proxy
:param data:
:return:
"""
if not data:
return None
# if list of proxies
if isinstance(data, list):
result = []
for item in data:
# skip invalid item
item = item.strip()
if not is_valid_proxy(item): continue
host, port = item.split(':')
result.append(Proxy(host=host, port=int(port)))
return result
if isinstance(data, str) and is_valid_proxy(data):
host, port = data.split(':')
return Proxy(host=host, port=int(port)) | [
"def",
"convert_proxy_or_proxies",
"(",
"data",
")",
":",
"if",
"not",
"data",
":",
"return",
"None",
"# if list of proxies",
"if",
"isinstance",
"(",
"data",
",",
"list",
")",
":",
"result",
"=",
"[",
"]",
"for",
"item",
"in",
"data",
":",
"# skip invalid item",
"item",
"=",
"item",
".",
"strip",
"(",
")",
"if",
"not",
"is_valid_proxy",
"(",
"item",
")",
":",
"continue",
"host",
",",
"port",
"=",
"item",
".",
"split",
"(",
"':'",
")",
"result",
".",
"append",
"(",
"Proxy",
"(",
"host",
"=",
"host",
",",
"port",
"=",
"int",
"(",
"port",
")",
")",
")",
"return",
"result",
"if",
"isinstance",
"(",
"data",
",",
"str",
")",
"and",
"is_valid_proxy",
"(",
"data",
")",
":",
"host",
",",
"port",
"=",
"data",
".",
"split",
"(",
"':'",
")",
"return",
"Proxy",
"(",
"host",
"=",
"host",
",",
"port",
"=",
"int",
"(",
"port",
")",
")"
] | [
13,
0
] | [
33,
47
] | python | en | ['en', 'error', 'th'] | False |
async_setup | (hass: HomeAssistant, config: Config) | Set up configured GIOS. | Set up configured GIOS. | async def async_setup(hass: HomeAssistant, config: Config) -> bool:
"""Set up configured GIOS."""
return True | [
"async",
"def",
"async_setup",
"(",
"hass",
":",
"HomeAssistant",
",",
"config",
":",
"Config",
")",
"->",
"bool",
":",
"return",
"True"
] | [
17,
0
] | [
19,
15
] | python | en | ['en', 'en', 'en'] | True |
async_setup_entry | (hass, config_entry) | Set up GIOS as config entry. | Set up GIOS as config entry. | async def async_setup_entry(hass, config_entry):
"""Set up GIOS as config entry."""
station_id = config_entry.data[CONF_STATION_ID]
_LOGGER.debug("Using station_id: %s", station_id)
websession = async_get_clientsession(hass)
coordinator = GiosDataUpdateCoordinator(hass, websession, station_id)
await coordinator.async_refresh()
if not coordinator.last_update_success:
raise ConfigEntryNotReady
hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][config_entry.entry_id] = coordinator
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, "air_quality")
)
return True | [
"async",
"def",
"async_setup_entry",
"(",
"hass",
",",
"config_entry",
")",
":",
"station_id",
"=",
"config_entry",
".",
"data",
"[",
"CONF_STATION_ID",
"]",
"_LOGGER",
".",
"debug",
"(",
"\"Using station_id: %s\"",
",",
"station_id",
")",
"websession",
"=",
"async_get_clientsession",
"(",
"hass",
")",
"coordinator",
"=",
"GiosDataUpdateCoordinator",
"(",
"hass",
",",
"websession",
",",
"station_id",
")",
"await",
"coordinator",
".",
"async_refresh",
"(",
")",
"if",
"not",
"coordinator",
".",
"last_update_success",
":",
"raise",
"ConfigEntryNotReady",
"hass",
".",
"data",
".",
"setdefault",
"(",
"DOMAIN",
",",
"{",
"}",
")",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"[",
"config_entry",
".",
"entry_id",
"]",
"=",
"coordinator",
"hass",
".",
"async_create_task",
"(",
"hass",
".",
"config_entries",
".",
"async_forward_entry_setup",
"(",
"config_entry",
",",
"\"air_quality\"",
")",
")",
"return",
"True"
] | [
22,
0
] | [
41,
15
] | python | en | ['en', 'en', 'en'] | True |
async_unload_entry | (hass, config_entry) | Unload a config entry. | Unload a config entry. | async def async_unload_entry(hass, config_entry):
"""Unload a config entry."""
hass.data[DOMAIN].pop(config_entry.entry_id)
await hass.config_entries.async_forward_entry_unload(config_entry, "air_quality")
return True | [
"async",
"def",
"async_unload_entry",
"(",
"hass",
",",
"config_entry",
")",
":",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
".",
"pop",
"(",
"config_entry",
".",
"entry_id",
")",
"await",
"hass",
".",
"config_entries",
".",
"async_forward_entry_unload",
"(",
"config_entry",
",",
"\"air_quality\"",
")",
"return",
"True"
] | [
44,
0
] | [
48,
15
] | python | en | ['en', 'es', 'en'] | True |
GiosDataUpdateCoordinator.__init__ | (self, hass, session, station_id) | Class to manage fetching GIOS data API. | Class to manage fetching GIOS data API. | def __init__(self, hass, session, station_id):
"""Class to manage fetching GIOS data API."""
self.gios = Gios(station_id, session)
super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=SCAN_INTERVAL) | [
"def",
"__init__",
"(",
"self",
",",
"hass",
",",
"session",
",",
"station_id",
")",
":",
"self",
".",
"gios",
"=",
"Gios",
"(",
"station_id",
",",
"session",
")",
"super",
"(",
")",
".",
"__init__",
"(",
"hass",
",",
"_LOGGER",
",",
"name",
"=",
"DOMAIN",
",",
"update_interval",
"=",
"SCAN_INTERVAL",
")"
] | [
54,
4
] | [
58,
83
] | python | en | ['en', 'en', 'en'] | True |
GiosDataUpdateCoordinator._async_update_data | (self) | Update data via library. | Update data via library. | async def _async_update_data(self):
"""Update data via library."""
try:
with timeout(30):
await self.gios.update()
except (
ApiError,
NoStationError,
ClientConnectorError,
InvalidSensorsData,
) as error:
raise UpdateFailed(error) from error
return self.gios.data | [
"async",
"def",
"_async_update_data",
"(",
"self",
")",
":",
"try",
":",
"with",
"timeout",
"(",
"30",
")",
":",
"await",
"self",
".",
"gios",
".",
"update",
"(",
")",
"except",
"(",
"ApiError",
",",
"NoStationError",
",",
"ClientConnectorError",
",",
"InvalidSensorsData",
",",
")",
"as",
"error",
":",
"raise",
"UpdateFailed",
"(",
"error",
")",
"from",
"error",
"return",
"self",
".",
"gios",
".",
"data"
] | [
60,
4
] | [
72,
29
] | python | en | ['fr', 'en', 'en'] | True |
device_reg | (hass) | Return an empty, loaded, registry. | Return an empty, loaded, registry. | def device_reg(hass):
"""Return an empty, loaded, registry."""
return mock_device_registry(hass) | [
"def",
"device_reg",
"(",
"hass",
")",
":",
"return",
"mock_device_registry",
"(",
"hass",
")"
] | [
20,
0
] | [
22,
37
] | python | en | ['en', 'fy', 'en'] | True |
entity_reg | (hass) | Return an empty, loaded, registry. | Return an empty, loaded, registry. | def entity_reg(hass):
"""Return an empty, loaded, registry."""
return mock_registry(hass) | [
"def",
"entity_reg",
"(",
"hass",
")",
":",
"return",
"mock_registry",
"(",
"hass",
")"
] | [
26,
0
] | [
28,
30
] | python | en | ['en', 'fy', 'en'] | True |
calls | (hass) | Track calls to a mock service. | Track calls to a mock service. | def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation") | [
"def",
"calls",
"(",
"hass",
")",
":",
"return",
"async_mock_service",
"(",
"hass",
",",
"\"test\"",
",",
"\"automation\"",
")"
] | [
32,
0
] | [
34,
57
] | python | en | ['en', 'en', 'en'] | True |
test_get_triggers | (hass, device_reg, entity_reg) | Test we get the expected triggers from a lock. | Test we get the expected triggers from a lock. | async def test_get_triggers(hass, device_reg, entity_reg):
"""Test we get the expected triggers from a lock."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_reg.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id)
expected_triggers = [
{
"platform": "device",
"domain": DOMAIN,
"type": "locked",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
{
"platform": "device",
"domain": DOMAIN,
"type": "unlocked",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
]
triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
assert_lists_same(triggers, expected_triggers) | [
"async",
"def",
"test_get_triggers",
"(",
"hass",
",",
"device_reg",
",",
"entity_reg",
")",
":",
"config_entry",
"=",
"MockConfigEntry",
"(",
"domain",
"=",
"\"test\"",
",",
"data",
"=",
"{",
"}",
")",
"config_entry",
".",
"add_to_hass",
"(",
"hass",
")",
"device_entry",
"=",
"device_reg",
".",
"async_get_or_create",
"(",
"config_entry_id",
"=",
"config_entry",
".",
"entry_id",
",",
"connections",
"=",
"{",
"(",
"device_registry",
".",
"CONNECTION_NETWORK_MAC",
",",
"\"12:34:56:AB:CD:EF\"",
")",
"}",
",",
")",
"entity_reg",
".",
"async_get_or_create",
"(",
"DOMAIN",
",",
"\"test\"",
",",
"\"5678\"",
",",
"device_id",
"=",
"device_entry",
".",
"id",
")",
"expected_triggers",
"=",
"[",
"{",
"\"platform\"",
":",
"\"device\"",
",",
"\"domain\"",
":",
"DOMAIN",
",",
"\"type\"",
":",
"\"locked\"",
",",
"\"device_id\"",
":",
"device_entry",
".",
"id",
",",
"\"entity_id\"",
":",
"f\"{DOMAIN}.test_5678\"",
",",
"}",
",",
"{",
"\"platform\"",
":",
"\"device\"",
",",
"\"domain\"",
":",
"DOMAIN",
",",
"\"type\"",
":",
"\"unlocked\"",
",",
"\"device_id\"",
":",
"device_entry",
".",
"id",
",",
"\"entity_id\"",
":",
"f\"{DOMAIN}.test_5678\"",
",",
"}",
",",
"]",
"triggers",
"=",
"await",
"async_get_device_automations",
"(",
"hass",
",",
"\"trigger\"",
",",
"device_entry",
".",
"id",
")",
"assert_lists_same",
"(",
"triggers",
",",
"expected_triggers",
")"
] | [
37,
0
] | [
63,
50
] | python | en | ['en', 'en', 'en'] | True |
test_if_fires_on_state_change | (hass, calls) | Test for turn_on and turn_off triggers firing. | Test for turn_on and turn_off triggers firing. | async def test_if_fires_on_state_change(hass, calls):
"""Test for turn_on and turn_off triggers firing."""
hass.states.async_set("lock.entity", STATE_UNLOCKED)
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "lock.entity",
"type": "locked",
},
"action": {
"service": "test.automation",
"data_template": {
"some": (
"locked - {{ trigger.platform}} - "
"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - "
"{{ trigger.to_state.state}} - {{ trigger.for }}"
)
},
},
},
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "lock.entity",
"type": "unlocked",
},
"action": {
"service": "test.automation",
"data_template": {
"some": (
"unlocked - {{ trigger.platform}} - "
"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - "
"{{ trigger.to_state.state}} - {{ trigger.for }}"
)
},
},
},
]
},
)
# Fake that the entity is turning on.
hass.states.async_set("lock.entity", STATE_LOCKED)
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].data[
"some"
] == "locked - device - {} - unlocked - locked - None".format("lock.entity")
# Fake that the entity is turning off.
hass.states.async_set("lock.entity", STATE_UNLOCKED)
await hass.async_block_till_done()
assert len(calls) == 2
assert calls[1].data[
"some"
] == "unlocked - device - {} - locked - unlocked - None".format("lock.entity") | [
"async",
"def",
"test_if_fires_on_state_change",
"(",
"hass",
",",
"calls",
")",
":",
"hass",
".",
"states",
".",
"async_set",
"(",
"\"lock.entity\"",
",",
"STATE_UNLOCKED",
")",
"assert",
"await",
"async_setup_component",
"(",
"hass",
",",
"automation",
".",
"DOMAIN",
",",
"{",
"automation",
".",
"DOMAIN",
":",
"[",
"{",
"\"trigger\"",
":",
"{",
"\"platform\"",
":",
"\"device\"",
",",
"\"domain\"",
":",
"DOMAIN",
",",
"\"device_id\"",
":",
"\"\"",
",",
"\"entity_id\"",
":",
"\"lock.entity\"",
",",
"\"type\"",
":",
"\"locked\"",
",",
"}",
",",
"\"action\"",
":",
"{",
"\"service\"",
":",
"\"test.automation\"",
",",
"\"data_template\"",
":",
"{",
"\"some\"",
":",
"(",
"\"locked - {{ trigger.platform}} - \"",
"\"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - \"",
"\"{{ trigger.to_state.state}} - {{ trigger.for }}\"",
")",
"}",
",",
"}",
",",
"}",
",",
"{",
"\"trigger\"",
":",
"{",
"\"platform\"",
":",
"\"device\"",
",",
"\"domain\"",
":",
"DOMAIN",
",",
"\"device_id\"",
":",
"\"\"",
",",
"\"entity_id\"",
":",
"\"lock.entity\"",
",",
"\"type\"",
":",
"\"unlocked\"",
",",
"}",
",",
"\"action\"",
":",
"{",
"\"service\"",
":",
"\"test.automation\"",
",",
"\"data_template\"",
":",
"{",
"\"some\"",
":",
"(",
"\"unlocked - {{ trigger.platform}} - \"",
"\"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - \"",
"\"{{ trigger.to_state.state}} - {{ trigger.for }}\"",
")",
"}",
",",
"}",
",",
"}",
",",
"]",
"}",
",",
")",
"# Fake that the entity is turning on.",
"hass",
".",
"states",
".",
"async_set",
"(",
"\"lock.entity\"",
",",
"STATE_LOCKED",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"len",
"(",
"calls",
")",
"==",
"1",
"assert",
"calls",
"[",
"0",
"]",
".",
"data",
"[",
"\"some\"",
"]",
"==",
"\"locked - device - {} - unlocked - locked - None\"",
".",
"format",
"(",
"\"lock.entity\"",
")",
"# Fake that the entity is turning off.",
"hass",
".",
"states",
".",
"async_set",
"(",
"\"lock.entity\"",
",",
"STATE_UNLOCKED",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"len",
"(",
"calls",
")",
"==",
"2",
"assert",
"calls",
"[",
"1",
"]",
".",
"data",
"[",
"\"some\"",
"]",
"==",
"\"unlocked - device - {} - locked - unlocked - None\"",
".",
"format",
"(",
"\"lock.entity\"",
")"
] | [
66,
0
] | [
131,
82
] | python | en | ['en', 'en', 'en'] | True |
test_scan_match_st | (hass, caplog) | Test matching based on ST. | Test matching based on ST. | async def test_scan_match_st(hass, caplog):
"""Test matching based on ST."""
scanner = ssdp.Scanner(hass, {"mock-domain": [{"st": "mock-st"}]})
with patch(
"netdisco.ssdp.scan",
return_value=[
Mock(
st="mock-st",
location=None,
values={"usn": "mock-usn", "server": "mock-server", "ext": ""},
)
],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert len(mock_init.mock_calls) == 1
assert mock_init.mock_calls[0][1][0] == "mock-domain"
assert mock_init.mock_calls[0][2]["context"] == {"source": "ssdp"}
assert mock_init.mock_calls[0][2]["data"] == {
ssdp.ATTR_SSDP_ST: "mock-st",
ssdp.ATTR_SSDP_LOCATION: None,
ssdp.ATTR_SSDP_USN: "mock-usn",
ssdp.ATTR_SSDP_SERVER: "mock-server",
ssdp.ATTR_SSDP_EXT: "",
}
assert "Failed to fetch ssdp data" not in caplog.text | [
"async",
"def",
"test_scan_match_st",
"(",
"hass",
",",
"caplog",
")",
":",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"\"mock-domain\"",
":",
"[",
"{",
"\"st\"",
":",
"\"mock-st\"",
"}",
"]",
"}",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"None",
",",
"values",
"=",
"{",
"\"usn\"",
":",
"\"mock-usn\"",
",",
"\"server\"",
":",
"\"mock-server\"",
",",
"\"ext\"",
":",
"\"\"",
"}",
",",
")",
"]",
",",
")",
",",
"patch",
".",
"object",
"(",
"hass",
".",
"config_entries",
".",
"flow",
",",
"\"async_init\"",
",",
"return_value",
"=",
"mock_coro",
"(",
")",
")",
"as",
"mock_init",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")",
"assert",
"len",
"(",
"mock_init",
".",
"mock_calls",
")",
"==",
"1",
"assert",
"mock_init",
".",
"mock_calls",
"[",
"0",
"]",
"[",
"1",
"]",
"[",
"0",
"]",
"==",
"\"mock-domain\"",
"assert",
"mock_init",
".",
"mock_calls",
"[",
"0",
"]",
"[",
"2",
"]",
"[",
"\"context\"",
"]",
"==",
"{",
"\"source\"",
":",
"\"ssdp\"",
"}",
"assert",
"mock_init",
".",
"mock_calls",
"[",
"0",
"]",
"[",
"2",
"]",
"[",
"\"data\"",
"]",
"==",
"{",
"ssdp",
".",
"ATTR_SSDP_ST",
":",
"\"mock-st\"",
",",
"ssdp",
".",
"ATTR_SSDP_LOCATION",
":",
"None",
",",
"ssdp",
".",
"ATTR_SSDP_USN",
":",
"\"mock-usn\"",
",",
"ssdp",
".",
"ATTR_SSDP_SERVER",
":",
"\"mock-server\"",
",",
"ssdp",
".",
"ATTR_SSDP_EXT",
":",
"\"\"",
",",
"}",
"assert",
"\"Failed to fetch ssdp data\"",
"not",
"in",
"caplog",
".",
"text"
] | [
12,
0
] | [
40,
57
] | python | en | ['en', 'en', 'en'] | True |
test_scan_match_upnp_devicedesc | (hass, aioclient_mock, key) | Test matching based on UPnP device description data. | Test matching based on UPnP device description data. | async def test_scan_match_upnp_devicedesc(hass, aioclient_mock, key):
"""Test matching based on UPnP device description data."""
aioclient_mock.get(
"http://1.1.1.1",
text=f"""
<root>
<device>
<{key}>Paulus</{key}>
</device>
</root>
""",
)
scanner = ssdp.Scanner(hass, {"mock-domain": [{key: "Paulus"}]})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert len(mock_init.mock_calls) == 1
assert mock_init.mock_calls[0][1][0] == "mock-domain"
assert mock_init.mock_calls[0][2]["context"] == {"source": "ssdp"} | [
"async",
"def",
"test_scan_match_upnp_devicedesc",
"(",
"hass",
",",
"aioclient_mock",
",",
"key",
")",
":",
"aioclient_mock",
".",
"get",
"(",
"\"http://1.1.1.1\"",
",",
"text",
"=",
"f\"\"\"\n<root>\n <device>\n <{key}>Paulus</{key}>\n </device>\n</root>\n \"\"\"",
",",
")",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"\"mock-domain\"",
":",
"[",
"{",
"key",
":",
"\"Paulus\"",
"}",
"]",
"}",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"\"http://1.1.1.1\"",
",",
"values",
"=",
"{",
"}",
")",
"]",
",",
")",
",",
"patch",
".",
"object",
"(",
"hass",
".",
"config_entries",
".",
"flow",
",",
"\"async_init\"",
",",
"return_value",
"=",
"mock_coro",
"(",
")",
")",
"as",
"mock_init",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")",
"assert",
"len",
"(",
"mock_init",
".",
"mock_calls",
")",
"==",
"1",
"assert",
"mock_init",
".",
"mock_calls",
"[",
"0",
"]",
"[",
"1",
"]",
"[",
"0",
"]",
"==",
"\"mock-domain\"",
"assert",
"mock_init",
".",
"mock_calls",
"[",
"0",
"]",
"[",
"2",
"]",
"[",
"\"context\"",
"]",
"==",
"{",
"\"source\"",
":",
"\"ssdp\"",
"}"
] | [
46,
0
] | [
70,
70
] | python | en | ['en', 'en', 'en'] | True |
test_scan_not_all_present | (hass, aioclient_mock) | Test match fails if some specified attributes are not present. | Test match fails if some specified attributes are not present. | async def test_scan_not_all_present(hass, aioclient_mock):
"""Test match fails if some specified attributes are not present."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>
<device>
<deviceType>Paulus</deviceType>
</device>
</root>
""",
)
scanner = ssdp.Scanner(
hass,
{
"mock-domain": [
{
ssdp.ATTR_UPNP_DEVICE_TYPE: "Paulus",
ssdp.ATTR_UPNP_MANUFACTURER: "Paulus",
}
]
},
)
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert not mock_init.mock_calls | [
"async",
"def",
"test_scan_not_all_present",
"(",
"hass",
",",
"aioclient_mock",
")",
":",
"aioclient_mock",
".",
"get",
"(",
"\"http://1.1.1.1\"",
",",
"text",
"=",
"\"\"\"\n<root>\n <device>\n <deviceType>Paulus</deviceType>\n </device>\n</root>\n \"\"\"",
",",
")",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"\"mock-domain\"",
":",
"[",
"{",
"ssdp",
".",
"ATTR_UPNP_DEVICE_TYPE",
":",
"\"Paulus\"",
",",
"ssdp",
".",
"ATTR_UPNP_MANUFACTURER",
":",
"\"Paulus\"",
",",
"}",
"]",
"}",
",",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"\"http://1.1.1.1\"",
",",
"values",
"=",
"{",
"}",
")",
"]",
",",
")",
",",
"patch",
".",
"object",
"(",
"hass",
".",
"config_entries",
".",
"flow",
",",
"\"async_init\"",
",",
"return_value",
"=",
"mock_coro",
"(",
")",
")",
"as",
"mock_init",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")",
"assert",
"not",
"mock_init",
".",
"mock_calls"
] | [
73,
0
] | [
105,
35
] | python | en | ['en', 'en', 'en'] | True |
test_scan_not_all_match | (hass, aioclient_mock) | Test match fails if some specified attribute values differ. | Test match fails if some specified attribute values differ. | async def test_scan_not_all_match(hass, aioclient_mock):
"""Test match fails if some specified attribute values differ."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>
<device>
<deviceType>Paulus</deviceType>
<manufacturer>Paulus</manufacturer>
</device>
</root>
""",
)
scanner = ssdp.Scanner(
hass,
{
"mock-domain": [
{
ssdp.ATTR_UPNP_DEVICE_TYPE: "Paulus",
ssdp.ATTR_UPNP_MANUFACTURER: "Not-Paulus",
}
]
},
)
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert not mock_init.mock_calls | [
"async",
"def",
"test_scan_not_all_match",
"(",
"hass",
",",
"aioclient_mock",
")",
":",
"aioclient_mock",
".",
"get",
"(",
"\"http://1.1.1.1\"",
",",
"text",
"=",
"\"\"\"\n<root>\n <device>\n <deviceType>Paulus</deviceType>\n <manufacturer>Paulus</manufacturer>\n </device>\n</root>\n \"\"\"",
",",
")",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"\"mock-domain\"",
":",
"[",
"{",
"ssdp",
".",
"ATTR_UPNP_DEVICE_TYPE",
":",
"\"Paulus\"",
",",
"ssdp",
".",
"ATTR_UPNP_MANUFACTURER",
":",
"\"Not-Paulus\"",
",",
"}",
"]",
"}",
",",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"\"http://1.1.1.1\"",
",",
"values",
"=",
"{",
"}",
")",
"]",
",",
")",
",",
"patch",
".",
"object",
"(",
"hass",
".",
"config_entries",
".",
"flow",
",",
"\"async_init\"",
",",
"return_value",
"=",
"mock_coro",
"(",
")",
")",
"as",
"mock_init",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")",
"assert",
"not",
"mock_init",
".",
"mock_calls"
] | [
108,
0
] | [
141,
35
] | python | en | ['en', 'en', 'en'] | True |
test_scan_description_fetch_fail | (hass, aioclient_mock, exc) | Test failing to fetch description. | Test failing to fetch description. | async def test_scan_description_fetch_fail(hass, aioclient_mock, exc):
"""Test failing to fetch description."""
aioclient_mock.get("http://1.1.1.1", exc=exc)
scanner = ssdp.Scanner(hass, {})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
):
await scanner.async_scan(None) | [
"async",
"def",
"test_scan_description_fetch_fail",
"(",
"hass",
",",
"aioclient_mock",
",",
"exc",
")",
":",
"aioclient_mock",
".",
"get",
"(",
"\"http://1.1.1.1\"",
",",
"exc",
"=",
"exc",
")",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"}",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"\"http://1.1.1.1\"",
",",
"values",
"=",
"{",
"}",
")",
"]",
",",
")",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")"
] | [
145,
0
] | [
154,
38
] | python | en | ['en', 'fr', 'en'] | True |
test_scan_description_parse_fail | (hass, aioclient_mock) | Test invalid XML. | Test invalid XML. | async def test_scan_description_parse_fail(hass, aioclient_mock):
"""Test invalid XML."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>INVALIDXML
""",
)
scanner = ssdp.Scanner(hass, {})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
):
await scanner.async_scan(None) | [
"async",
"def",
"test_scan_description_parse_fail",
"(",
"hass",
",",
"aioclient_mock",
")",
":",
"aioclient_mock",
".",
"get",
"(",
"\"http://1.1.1.1\"",
",",
"text",
"=",
"\"\"\"\n<root>INVALIDXML\n \"\"\"",
",",
")",
"scanner",
"=",
"ssdp",
".",
"Scanner",
"(",
"hass",
",",
"{",
"}",
")",
"with",
"patch",
"(",
"\"netdisco.ssdp.scan\"",
",",
"return_value",
"=",
"[",
"Mock",
"(",
"st",
"=",
"\"mock-st\"",
",",
"location",
"=",
"\"http://1.1.1.1\"",
",",
"values",
"=",
"{",
"}",
")",
"]",
",",
")",
":",
"await",
"scanner",
".",
"async_scan",
"(",
"None",
")"
] | [
157,
0
] | [
171,
38
] | python | en | ['en', 'et', 'en'] | True |
OnnxExportTestCase.test_infer_dynamic_axis_pytorch | (self) |
Validate the dynamic axis generated for each parameters are correct
|
Validate the dynamic axis generated for each parameters are correct
| def test_infer_dynamic_axis_pytorch(self):
"""
Validate the dynamic axis generated for each parameters are correct
"""
from transformers import BertModel
model = BertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"))
tokenizer = BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random")
self._test_infer_dynamic_axis(model, tokenizer, "pt") | [
"def",
"test_infer_dynamic_axis_pytorch",
"(",
"self",
")",
":",
"from",
"transformers",
"import",
"BertModel",
"model",
"=",
"BertModel",
"(",
"BertConfig",
".",
"from_pretrained",
"(",
"\"lysandre/tiny-bert-random\"",
")",
")",
"tokenizer",
"=",
"BertTokenizerFast",
".",
"from_pretrained",
"(",
"\"lysandre/tiny-bert-random\"",
")",
"self",
".",
"_test_infer_dynamic_axis",
"(",
"model",
",",
"tokenizer",
",",
"\"pt\"",
")"
] | [
116,
4
] | [
124,
61
] | python | en | ['en', 'error', 'th'] | False |
OnnxExportTestCase.test_infer_dynamic_axis_tf | (self) |
Validate the dynamic axis generated for each parameters are correct
|
Validate the dynamic axis generated for each parameters are correct
| def test_infer_dynamic_axis_tf(self):
"""
Validate the dynamic axis generated for each parameters are correct
"""
from transformers import TFBertModel
model = TFBertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"))
tokenizer = BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random")
self._test_infer_dynamic_axis(model, tokenizer, "tf") | [
"def",
"test_infer_dynamic_axis_tf",
"(",
"self",
")",
":",
"from",
"transformers",
"import",
"TFBertModel",
"model",
"=",
"TFBertModel",
"(",
"BertConfig",
".",
"from_pretrained",
"(",
"\"lysandre/tiny-bert-random\"",
")",
")",
"tokenizer",
"=",
"BertTokenizerFast",
".",
"from_pretrained",
"(",
"\"lysandre/tiny-bert-random\"",
")",
"self",
".",
"_test_infer_dynamic_axis",
"(",
"model",
",",
"tokenizer",
",",
"\"tf\"",
")"
] | [
129,
4
] | [
137,
61
] | python | en | ['en', 'error', 'th'] | False |
OnnxExportTestCase.test_ensure_valid_input | (self) |
Validate parameters are correctly exported
GPT2 has "past" parameter in the middle of input_ids, token_type_ids and attention_mask.
ONNX doesn't support export with a dictionary, only a tuple. Thus we need to ensure we remove
token_type_ids and attention_mask for now to not having a None tensor in the middle
|
Validate parameters are correctly exported
GPT2 has "past" parameter in the middle of input_ids, token_type_ids and attention_mask.
ONNX doesn't support export with a dictionary, only a tuple. Thus we need to ensure we remove
token_type_ids and attention_mask for now to not having a None tensor in the middle
| def test_ensure_valid_input(self):
"""
Validate parameters are correctly exported
GPT2 has "past" parameter in the middle of input_ids, token_type_ids and attention_mask.
ONNX doesn't support export with a dictionary, only a tuple. Thus we need to ensure we remove
token_type_ids and attention_mask for now to not having a None tensor in the middle
"""
# All generated args are valid
input_names = ["input_ids", "attention_mask", "token_type_ids"]
tokens = {"input_ids": [1, 2, 3, 4], "attention_mask": [0, 0, 0, 0], "token_type_ids": [1, 1, 1, 1]}
ordered_input_names, inputs_args = ensure_valid_input(FuncContiguousArgs(), tokens, input_names)
# Should have exactly the same number of args (all are valid)
self.assertEqual(len(inputs_args), 3)
# Should have exactly the same input names
self.assertEqual(set(ordered_input_names), set(input_names))
# Parameter should be reordered according to their respective place in the function:
# (input_ids, token_type_ids, attention_mask)
self.assertEqual(inputs_args, (tokens["input_ids"], tokens["token_type_ids"], tokens["attention_mask"]))
# Generated args are interleaved with another args (for instance parameter "past" in GPT2)
ordered_input_names, inputs_args = ensure_valid_input(FuncNonContiguousArgs(), tokens, input_names)
# Should have exactly the one arg (all before the one not provided "some_other_args")
self.assertEqual(len(inputs_args), 1)
self.assertEqual(len(ordered_input_names), 1)
# Should have only "input_ids"
self.assertEqual(inputs_args[0], tokens["input_ids"])
self.assertEqual(ordered_input_names[0], "input_ids") | [
"def",
"test_ensure_valid_input",
"(",
"self",
")",
":",
"# All generated args are valid",
"input_names",
"=",
"[",
"\"input_ids\"",
",",
"\"attention_mask\"",
",",
"\"token_type_ids\"",
"]",
"tokens",
"=",
"{",
"\"input_ids\"",
":",
"[",
"1",
",",
"2",
",",
"3",
",",
"4",
"]",
",",
"\"attention_mask\"",
":",
"[",
"0",
",",
"0",
",",
"0",
",",
"0",
"]",
",",
"\"token_type_ids\"",
":",
"[",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
"}",
"ordered_input_names",
",",
"inputs_args",
"=",
"ensure_valid_input",
"(",
"FuncContiguousArgs",
"(",
")",
",",
"tokens",
",",
"input_names",
")",
"# Should have exactly the same number of args (all are valid)",
"self",
".",
"assertEqual",
"(",
"len",
"(",
"inputs_args",
")",
",",
"3",
")",
"# Should have exactly the same input names",
"self",
".",
"assertEqual",
"(",
"set",
"(",
"ordered_input_names",
")",
",",
"set",
"(",
"input_names",
")",
")",
"# Parameter should be reordered according to their respective place in the function:",
"# (input_ids, token_type_ids, attention_mask)",
"self",
".",
"assertEqual",
"(",
"inputs_args",
",",
"(",
"tokens",
"[",
"\"input_ids\"",
"]",
",",
"tokens",
"[",
"\"token_type_ids\"",
"]",
",",
"tokens",
"[",
"\"attention_mask\"",
"]",
")",
")",
"# Generated args are interleaved with another args (for instance parameter \"past\" in GPT2)",
"ordered_input_names",
",",
"inputs_args",
"=",
"ensure_valid_input",
"(",
"FuncNonContiguousArgs",
"(",
")",
",",
"tokens",
",",
"input_names",
")",
"# Should have exactly the one arg (all before the one not provided \"some_other_args\")",
"self",
".",
"assertEqual",
"(",
"len",
"(",
"inputs_args",
")",
",",
"1",
")",
"self",
".",
"assertEqual",
"(",
"len",
"(",
"ordered_input_names",
")",
",",
"1",
")",
"# Should have only \"input_ids\"",
"self",
".",
"assertEqual",
"(",
"inputs_args",
"[",
"0",
"]",
",",
"tokens",
"[",
"\"input_ids\"",
"]",
")",
"self",
".",
"assertEqual",
"(",
"ordered_input_names",
"[",
"0",
"]",
",",
"\"input_ids\"",
")"
] | [
159,
4
] | [
190,
61
] | python | en | ['en', 'error', 'th'] | False |
async_setup_platform | (
hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None
) | Initialize light.group platform. | Initialize light.group platform. | async def async_setup_platform(
hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None
) -> None:
"""Initialize light.group platform."""
async_add_entities(
[LightGroup(cast(str, config.get(CONF_NAME)), config[CONF_ENTITIES])]
) | [
"async",
"def",
"async_setup_platform",
"(",
"hass",
":",
"HomeAssistantType",
",",
"config",
":",
"ConfigType",
",",
"async_add_entities",
",",
"discovery_info",
"=",
"None",
")",
"->",
"None",
":",
"async_add_entities",
"(",
"[",
"LightGroup",
"(",
"cast",
"(",
"str",
",",
"config",
".",
"get",
"(",
"CONF_NAME",
")",
")",
",",
"config",
"[",
"CONF_ENTITIES",
"]",
")",
"]",
")"
] | [
68,
0
] | [
74,
5
] | python | en | ['en', 'cs', 'en'] | True |
_find_state_attributes | (states: List[State], key: str) | Find attributes with matching key from states. | Find attributes with matching key from states. | def _find_state_attributes(states: List[State], key: str) -> Iterator[Any]:
"""Find attributes with matching key from states."""
for state in states:
value = state.attributes.get(key)
if value is not None:
yield value | [
"def",
"_find_state_attributes",
"(",
"states",
":",
"List",
"[",
"State",
"]",
",",
"key",
":",
"str",
")",
"->",
"Iterator",
"[",
"Any",
"]",
":",
"for",
"state",
"in",
"states",
":",
"value",
"=",
"state",
".",
"attributes",
".",
"get",
"(",
"key",
")",
"if",
"value",
"is",
"not",
"None",
":",
"yield",
"value"
] | [
334,
0
] | [
339,
23
] | python | en | ['en', 'en', 'en'] | True |
_mean_int | (*args) | Return the mean of the supplied values. | Return the mean of the supplied values. | def _mean_int(*args):
"""Return the mean of the supplied values."""
return int(sum(args) / len(args)) | [
"def",
"_mean_int",
"(",
"*",
"args",
")",
":",
"return",
"int",
"(",
"sum",
"(",
"args",
")",
"/",
"len",
"(",
"args",
")",
")"
] | [
342,
0
] | [
344,
37
] | python | en | ['en', 'en', 'en'] | True |
_mean_tuple | (*args) | Return the mean values along the columns of the supplied values. | Return the mean values along the columns of the supplied values. | def _mean_tuple(*args):
"""Return the mean values along the columns of the supplied values."""
return tuple(sum(x) / len(x) for x in zip(*args)) | [
"def",
"_mean_tuple",
"(",
"*",
"args",
")",
":",
"return",
"tuple",
"(",
"sum",
"(",
"x",
")",
"/",
"len",
"(",
"x",
")",
"for",
"x",
"in",
"zip",
"(",
"*",
"args",
")",
")"
] | [
347,
0
] | [
349,
53
] | python | en | ['en', 'en', 'en'] | True |
_reduce_attribute | (
states: List[State],
key: str,
default: Optional[Any] = None,
reduce: Callable[..., Any] = _mean_int,
) | Find the first attribute matching key from states.
If none are found, return default.
| Find the first attribute matching key from states. | def _reduce_attribute(
states: List[State],
key: str,
default: Optional[Any] = None,
reduce: Callable[..., Any] = _mean_int,
) -> Any:
"""Find the first attribute matching key from states.
If none are found, return default.
"""
attrs = list(_find_state_attributes(states, key))
if not attrs:
return default
if len(attrs) == 1:
return attrs[0]
return reduce(*attrs) | [
"def",
"_reduce_attribute",
"(",
"states",
":",
"List",
"[",
"State",
"]",
",",
"key",
":",
"str",
",",
"default",
":",
"Optional",
"[",
"Any",
"]",
"=",
"None",
",",
"reduce",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
"=",
"_mean_int",
",",
")",
"->",
"Any",
":",
"attrs",
"=",
"list",
"(",
"_find_state_attributes",
"(",
"states",
",",
"key",
")",
")",
"if",
"not",
"attrs",
":",
"return",
"default",
"if",
"len",
"(",
"attrs",
")",
"==",
"1",
":",
"return",
"attrs",
"[",
"0",
"]",
"return",
"reduce",
"(",
"*",
"attrs",
")"
] | [
352,
0
] | [
370,
25
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.__init__ | (self, name: str, entity_ids: List[str]) | Initialize a light group. | Initialize a light group. | def __init__(self, name: str, entity_ids: List[str]) -> None:
"""Initialize a light group."""
self._name = name
self._entity_ids = entity_ids
self._is_on = False
self._available = False
self._icon = "mdi:lightbulb-group"
self._brightness: Optional[int] = None
self._hs_color: Optional[Tuple[float, float]] = None
self._color_temp: Optional[int] = None
self._min_mireds: Optional[int] = 154
self._max_mireds: Optional[int] = 500
self._white_value: Optional[int] = None
self._effect_list: Optional[List[str]] = None
self._effect: Optional[str] = None
self._supported_features: int = 0 | [
"def",
"__init__",
"(",
"self",
",",
"name",
":",
"str",
",",
"entity_ids",
":",
"List",
"[",
"str",
"]",
")",
"->",
"None",
":",
"self",
".",
"_name",
"=",
"name",
"self",
".",
"_entity_ids",
"=",
"entity_ids",
"self",
".",
"_is_on",
"=",
"False",
"self",
".",
"_available",
"=",
"False",
"self",
".",
"_icon",
"=",
"\"mdi:lightbulb-group\"",
"self",
".",
"_brightness",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
"self",
".",
"_hs_color",
":",
"Optional",
"[",
"Tuple",
"[",
"float",
",",
"float",
"]",
"]",
"=",
"None",
"self",
".",
"_color_temp",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
"self",
".",
"_min_mireds",
":",
"Optional",
"[",
"int",
"]",
"=",
"154",
"self",
".",
"_max_mireds",
":",
"Optional",
"[",
"int",
"]",
"=",
"500",
"self",
".",
"_white_value",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
"self",
".",
"_effect_list",
":",
"Optional",
"[",
"List",
"[",
"str",
"]",
"]",
"=",
"None",
"self",
".",
"_effect",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
"self",
".",
"_supported_features",
":",
"int",
"=",
"0"
] | [
80,
4
] | [
95,
41
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.async_added_to_hass | (self) | Register callbacks. | Register callbacks. | async def async_added_to_hass(self) -> None:
"""Register callbacks."""
async def async_state_changed_listener(event):
"""Handle child updates."""
self.async_set_context(event.context)
await self.async_defer_or_update_ha_state()
assert self.hass
self.async_on_remove(
async_track_state_change_event(
self.hass, self._entity_ids, async_state_changed_listener
)
)
if self.hass.state == CoreState.running:
await self.async_update()
return
await super().async_added_to_hass() | [
"async",
"def",
"async_added_to_hass",
"(",
"self",
")",
"->",
"None",
":",
"async",
"def",
"async_state_changed_listener",
"(",
"event",
")",
":",
"\"\"\"Handle child updates.\"\"\"",
"self",
".",
"async_set_context",
"(",
"event",
".",
"context",
")",
"await",
"self",
".",
"async_defer_or_update_ha_state",
"(",
")",
"assert",
"self",
".",
"hass",
"self",
".",
"async_on_remove",
"(",
"async_track_state_change_event",
"(",
"self",
".",
"hass",
",",
"self",
".",
"_entity_ids",
",",
"async_state_changed_listener",
")",
")",
"if",
"self",
".",
"hass",
".",
"state",
"==",
"CoreState",
".",
"running",
":",
"await",
"self",
".",
"async_update",
"(",
")",
"return",
"await",
"super",
"(",
")",
".",
"async_added_to_hass",
"(",
")"
] | [
97,
4
] | [
116,
43
] | python | en | ['en', 'no', 'en'] | False |
LightGroup.name | (self) | Return the name of the entity. | Return the name of the entity. | def name(self) -> str:
"""Return the name of the entity."""
return self._name | [
"def",
"name",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_name"
] | [
119,
4
] | [
121,
25
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.is_on | (self) | Return the on/off state of the light group. | Return the on/off state of the light group. | def is_on(self) -> bool:
"""Return the on/off state of the light group."""
return self._is_on | [
"def",
"is_on",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"self",
".",
"_is_on"
] | [
124,
4
] | [
126,
26
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.available | (self) | Return whether the light group is available. | Return whether the light group is available. | def available(self) -> bool:
"""Return whether the light group is available."""
return self._available | [
"def",
"available",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"self",
".",
"_available"
] | [
129,
4
] | [
131,
30
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.icon | (self) | Return the light group icon. | Return the light group icon. | def icon(self):
"""Return the light group icon."""
return self._icon | [
"def",
"icon",
"(",
"self",
")",
":",
"return",
"self",
".",
"_icon"
] | [
134,
4
] | [
136,
25
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.brightness | (self) | Return the brightness of this light group between 0..255. | Return the brightness of this light group between 0..255. | def brightness(self) -> Optional[int]:
"""Return the brightness of this light group between 0..255."""
return self._brightness | [
"def",
"brightness",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"return",
"self",
".",
"_brightness"
] | [
139,
4
] | [
141,
31
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.hs_color | (self) | Return the HS color value [float, float]. | Return the HS color value [float, float]. | def hs_color(self) -> Optional[Tuple[float, float]]:
"""Return the HS color value [float, float]."""
return self._hs_color | [
"def",
"hs_color",
"(",
"self",
")",
"->",
"Optional",
"[",
"Tuple",
"[",
"float",
",",
"float",
"]",
"]",
":",
"return",
"self",
".",
"_hs_color"
] | [
144,
4
] | [
146,
29
] | python | en | ['en', 'da', 'en'] | True |
LightGroup.color_temp | (self) | Return the CT color value in mireds. | Return the CT color value in mireds. | def color_temp(self) -> Optional[int]:
"""Return the CT color value in mireds."""
return self._color_temp | [
"def",
"color_temp",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"return",
"self",
".",
"_color_temp"
] | [
149,
4
] | [
151,
31
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.min_mireds | (self) | Return the coldest color_temp that this light group supports. | Return the coldest color_temp that this light group supports. | def min_mireds(self) -> Optional[int]:
"""Return the coldest color_temp that this light group supports."""
return self._min_mireds | [
"def",
"min_mireds",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"return",
"self",
".",
"_min_mireds"
] | [
154,
4
] | [
156,
31
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.max_mireds | (self) | Return the warmest color_temp that this light group supports. | Return the warmest color_temp that this light group supports. | def max_mireds(self) -> Optional[int]:
"""Return the warmest color_temp that this light group supports."""
return self._max_mireds | [
"def",
"max_mireds",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"return",
"self",
".",
"_max_mireds"
] | [
159,
4
] | [
161,
31
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.white_value | (self) | Return the white value of this light group between 0..255. | Return the white value of this light group between 0..255. | def white_value(self) -> Optional[int]:
"""Return the white value of this light group between 0..255."""
return self._white_value | [
"def",
"white_value",
"(",
"self",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"return",
"self",
".",
"_white_value"
] | [
164,
4
] | [
166,
32
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.effect_list | (self) | Return the list of supported effects. | Return the list of supported effects. | def effect_list(self) -> Optional[List[str]]:
"""Return the list of supported effects."""
return self._effect_list | [
"def",
"effect_list",
"(",
"self",
")",
"->",
"Optional",
"[",
"List",
"[",
"str",
"]",
"]",
":",
"return",
"self",
".",
"_effect_list"
] | [
169,
4
] | [
171,
32
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.effect | (self) | Return the current effect. | Return the current effect. | def effect(self) -> Optional[str]:
"""Return the current effect."""
return self._effect | [
"def",
"effect",
"(",
"self",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"return",
"self",
".",
"_effect"
] | [
174,
4
] | [
176,
27
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.supported_features | (self) | Flag supported features. | Flag supported features. | def supported_features(self) -> int:
"""Flag supported features."""
return self._supported_features | [
"def",
"supported_features",
"(",
"self",
")",
"->",
"int",
":",
"return",
"self",
".",
"_supported_features"
] | [
179,
4
] | [
181,
39
] | python | en | ['da', 'en', 'en'] | True |
LightGroup.should_poll | (self) | No polling needed for a light group. | No polling needed for a light group. | def should_poll(self) -> bool:
"""No polling needed for a light group."""
return False | [
"def",
"should_poll",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"False"
] | [
184,
4
] | [
186,
20
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.device_state_attributes | (self) | Return the state attributes for the light group. | Return the state attributes for the light group. | def device_state_attributes(self):
"""Return the state attributes for the light group."""
return {ATTR_ENTITY_ID: self._entity_ids} | [
"def",
"device_state_attributes",
"(",
"self",
")",
":",
"return",
"{",
"ATTR_ENTITY_ID",
":",
"self",
".",
"_entity_ids",
"}"
] | [
189,
4
] | [
191,
49
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.async_turn_on | (self, **kwargs) | Forward the turn_on command to all lights in the light group. | Forward the turn_on command to all lights in the light group. | async def async_turn_on(self, **kwargs):
"""Forward the turn_on command to all lights in the light group."""
data = {ATTR_ENTITY_ID: self._entity_ids}
emulate_color_temp_entity_ids = []
if ATTR_BRIGHTNESS in kwargs:
data[ATTR_BRIGHTNESS] = kwargs[ATTR_BRIGHTNESS]
if ATTR_HS_COLOR in kwargs:
data[ATTR_HS_COLOR] = kwargs[ATTR_HS_COLOR]
if ATTR_COLOR_TEMP in kwargs:
data[ATTR_COLOR_TEMP] = kwargs[ATTR_COLOR_TEMP]
# Create a new entity list to mutate
updated_entities = list(self._entity_ids)
# Walk through initial entity ids, split entity lists by support
for entity_id in self._entity_ids:
state = self.hass.states.get(entity_id)
if not state:
continue
support = state.attributes.get(ATTR_SUPPORTED_FEATURES)
# Only pass color temperature to supported entity_ids
if bool(support & SUPPORT_COLOR) and not bool(
support & SUPPORT_COLOR_TEMP
):
emulate_color_temp_entity_ids.append(entity_id)
updated_entities.remove(entity_id)
data[ATTR_ENTITY_ID] = updated_entities
if ATTR_WHITE_VALUE in kwargs:
data[ATTR_WHITE_VALUE] = kwargs[ATTR_WHITE_VALUE]
if ATTR_EFFECT in kwargs:
data[ATTR_EFFECT] = kwargs[ATTR_EFFECT]
if ATTR_TRANSITION in kwargs:
data[ATTR_TRANSITION] = kwargs[ATTR_TRANSITION]
if ATTR_FLASH in kwargs:
data[ATTR_FLASH] = kwargs[ATTR_FLASH]
if not emulate_color_temp_entity_ids:
await self.hass.services.async_call(
light.DOMAIN,
light.SERVICE_TURN_ON,
data,
blocking=True,
context=self._context,
)
return
emulate_color_temp_data = data.copy()
temp_k = color_util.color_temperature_mired_to_kelvin(
emulate_color_temp_data[ATTR_COLOR_TEMP]
)
hs_color = color_util.color_temperature_to_hs(temp_k)
emulate_color_temp_data[ATTR_HS_COLOR] = hs_color
del emulate_color_temp_data[ATTR_COLOR_TEMP]
emulate_color_temp_data[ATTR_ENTITY_ID] = emulate_color_temp_entity_ids
await asyncio.gather(
self.hass.services.async_call(
light.DOMAIN,
light.SERVICE_TURN_ON,
data,
blocking=True,
context=self._context,
),
self.hass.services.async_call(
light.DOMAIN,
light.SERVICE_TURN_ON,
emulate_color_temp_data,
blocking=True,
context=self._context,
),
) | [
"async",
"def",
"async_turn_on",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"self",
".",
"_entity_ids",
"}",
"emulate_color_temp_entity_ids",
"=",
"[",
"]",
"if",
"ATTR_BRIGHTNESS",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_BRIGHTNESS",
"]",
"=",
"kwargs",
"[",
"ATTR_BRIGHTNESS",
"]",
"if",
"ATTR_HS_COLOR",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_HS_COLOR",
"]",
"=",
"kwargs",
"[",
"ATTR_HS_COLOR",
"]",
"if",
"ATTR_COLOR_TEMP",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_COLOR_TEMP",
"]",
"=",
"kwargs",
"[",
"ATTR_COLOR_TEMP",
"]",
"# Create a new entity list to mutate",
"updated_entities",
"=",
"list",
"(",
"self",
".",
"_entity_ids",
")",
"# Walk through initial entity ids, split entity lists by support",
"for",
"entity_id",
"in",
"self",
".",
"_entity_ids",
":",
"state",
"=",
"self",
".",
"hass",
".",
"states",
".",
"get",
"(",
"entity_id",
")",
"if",
"not",
"state",
":",
"continue",
"support",
"=",
"state",
".",
"attributes",
".",
"get",
"(",
"ATTR_SUPPORTED_FEATURES",
")",
"# Only pass color temperature to supported entity_ids",
"if",
"bool",
"(",
"support",
"&",
"SUPPORT_COLOR",
")",
"and",
"not",
"bool",
"(",
"support",
"&",
"SUPPORT_COLOR_TEMP",
")",
":",
"emulate_color_temp_entity_ids",
".",
"append",
"(",
"entity_id",
")",
"updated_entities",
".",
"remove",
"(",
"entity_id",
")",
"data",
"[",
"ATTR_ENTITY_ID",
"]",
"=",
"updated_entities",
"if",
"ATTR_WHITE_VALUE",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_WHITE_VALUE",
"]",
"=",
"kwargs",
"[",
"ATTR_WHITE_VALUE",
"]",
"if",
"ATTR_EFFECT",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_EFFECT",
"]",
"=",
"kwargs",
"[",
"ATTR_EFFECT",
"]",
"if",
"ATTR_TRANSITION",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_TRANSITION",
"]",
"=",
"kwargs",
"[",
"ATTR_TRANSITION",
"]",
"if",
"ATTR_FLASH",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_FLASH",
"]",
"=",
"kwargs",
"[",
"ATTR_FLASH",
"]",
"if",
"not",
"emulate_color_temp_entity_ids",
":",
"await",
"self",
".",
"hass",
".",
"services",
".",
"async_call",
"(",
"light",
".",
"DOMAIN",
",",
"light",
".",
"SERVICE_TURN_ON",
",",
"data",
",",
"blocking",
"=",
"True",
",",
"context",
"=",
"self",
".",
"_context",
",",
")",
"return",
"emulate_color_temp_data",
"=",
"data",
".",
"copy",
"(",
")",
"temp_k",
"=",
"color_util",
".",
"color_temperature_mired_to_kelvin",
"(",
"emulate_color_temp_data",
"[",
"ATTR_COLOR_TEMP",
"]",
")",
"hs_color",
"=",
"color_util",
".",
"color_temperature_to_hs",
"(",
"temp_k",
")",
"emulate_color_temp_data",
"[",
"ATTR_HS_COLOR",
"]",
"=",
"hs_color",
"del",
"emulate_color_temp_data",
"[",
"ATTR_COLOR_TEMP",
"]",
"emulate_color_temp_data",
"[",
"ATTR_ENTITY_ID",
"]",
"=",
"emulate_color_temp_entity_ids",
"await",
"asyncio",
".",
"gather",
"(",
"self",
".",
"hass",
".",
"services",
".",
"async_call",
"(",
"light",
".",
"DOMAIN",
",",
"light",
".",
"SERVICE_TURN_ON",
",",
"data",
",",
"blocking",
"=",
"True",
",",
"context",
"=",
"self",
".",
"_context",
",",
")",
",",
"self",
".",
"hass",
".",
"services",
".",
"async_call",
"(",
"light",
".",
"DOMAIN",
",",
"light",
".",
"SERVICE_TURN_ON",
",",
"emulate_color_temp_data",
",",
"blocking",
"=",
"True",
",",
"context",
"=",
"self",
".",
"_context",
",",
")",
",",
")"
] | [
193,
4
] | [
271,
9
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.async_turn_off | (self, **kwargs) | Forward the turn_off command to all lights in the light group. | Forward the turn_off command to all lights in the light group. | async def async_turn_off(self, **kwargs):
"""Forward the turn_off command to all lights in the light group."""
data = {ATTR_ENTITY_ID: self._entity_ids}
if ATTR_TRANSITION in kwargs:
data[ATTR_TRANSITION] = kwargs[ATTR_TRANSITION]
await self.hass.services.async_call(
light.DOMAIN,
light.SERVICE_TURN_OFF,
data,
blocking=True,
context=self._context,
) | [
"async",
"def",
"async_turn_off",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"self",
".",
"_entity_ids",
"}",
"if",
"ATTR_TRANSITION",
"in",
"kwargs",
":",
"data",
"[",
"ATTR_TRANSITION",
"]",
"=",
"kwargs",
"[",
"ATTR_TRANSITION",
"]",
"await",
"self",
".",
"hass",
".",
"services",
".",
"async_call",
"(",
"light",
".",
"DOMAIN",
",",
"light",
".",
"SERVICE_TURN_OFF",
",",
"data",
",",
"blocking",
"=",
"True",
",",
"context",
"=",
"self",
".",
"_context",
",",
")"
] | [
273,
4
] | [
286,
9
] | python | en | ['en', 'en', 'en'] | True |
LightGroup.async_update | (self) | Query all members and determine the light group state. | Query all members and determine the light group state. | async def async_update(self):
"""Query all members and determine the light group state."""
all_states = [self.hass.states.get(x) for x in self._entity_ids]
states: List[State] = list(filter(None, all_states))
on_states = [state for state in states if state.state == STATE_ON]
self._is_on = len(on_states) > 0
self._available = any(state.state != STATE_UNAVAILABLE for state in states)
self._brightness = _reduce_attribute(on_states, ATTR_BRIGHTNESS)
self._hs_color = _reduce_attribute(on_states, ATTR_HS_COLOR, reduce=_mean_tuple)
self._white_value = _reduce_attribute(on_states, ATTR_WHITE_VALUE)
self._color_temp = _reduce_attribute(on_states, ATTR_COLOR_TEMP)
self._min_mireds = _reduce_attribute(
states, ATTR_MIN_MIREDS, default=154, reduce=min
)
self._max_mireds = _reduce_attribute(
states, ATTR_MAX_MIREDS, default=500, reduce=max
)
self._effect_list = None
all_effect_lists = list(_find_state_attributes(states, ATTR_EFFECT_LIST))
if all_effect_lists:
# Merge all effects from all effect_lists with a union merge.
self._effect_list = list(set().union(*all_effect_lists))
self._effect = None
all_effects = list(_find_state_attributes(on_states, ATTR_EFFECT))
if all_effects:
# Report the most common effect.
effects_count = Counter(itertools.chain(all_effects))
self._effect = effects_count.most_common(1)[0][0]
self._supported_features = 0
for support in _find_state_attributes(states, ATTR_SUPPORTED_FEATURES):
# Merge supported features by emulating support for every feature
# we find.
self._supported_features |= support
# Bitwise-and the supported features with the GroupedLight's features
# so that we don't break in the future when a new feature is added.
self._supported_features &= SUPPORT_GROUP_LIGHT | [
"async",
"def",
"async_update",
"(",
"self",
")",
":",
"all_states",
"=",
"[",
"self",
".",
"hass",
".",
"states",
".",
"get",
"(",
"x",
")",
"for",
"x",
"in",
"self",
".",
"_entity_ids",
"]",
"states",
":",
"List",
"[",
"State",
"]",
"=",
"list",
"(",
"filter",
"(",
"None",
",",
"all_states",
")",
")",
"on_states",
"=",
"[",
"state",
"for",
"state",
"in",
"states",
"if",
"state",
".",
"state",
"==",
"STATE_ON",
"]",
"self",
".",
"_is_on",
"=",
"len",
"(",
"on_states",
")",
">",
"0",
"self",
".",
"_available",
"=",
"any",
"(",
"state",
".",
"state",
"!=",
"STATE_UNAVAILABLE",
"for",
"state",
"in",
"states",
")",
"self",
".",
"_brightness",
"=",
"_reduce_attribute",
"(",
"on_states",
",",
"ATTR_BRIGHTNESS",
")",
"self",
".",
"_hs_color",
"=",
"_reduce_attribute",
"(",
"on_states",
",",
"ATTR_HS_COLOR",
",",
"reduce",
"=",
"_mean_tuple",
")",
"self",
".",
"_white_value",
"=",
"_reduce_attribute",
"(",
"on_states",
",",
"ATTR_WHITE_VALUE",
")",
"self",
".",
"_color_temp",
"=",
"_reduce_attribute",
"(",
"on_states",
",",
"ATTR_COLOR_TEMP",
")",
"self",
".",
"_min_mireds",
"=",
"_reduce_attribute",
"(",
"states",
",",
"ATTR_MIN_MIREDS",
",",
"default",
"=",
"154",
",",
"reduce",
"=",
"min",
")",
"self",
".",
"_max_mireds",
"=",
"_reduce_attribute",
"(",
"states",
",",
"ATTR_MAX_MIREDS",
",",
"default",
"=",
"500",
",",
"reduce",
"=",
"max",
")",
"self",
".",
"_effect_list",
"=",
"None",
"all_effect_lists",
"=",
"list",
"(",
"_find_state_attributes",
"(",
"states",
",",
"ATTR_EFFECT_LIST",
")",
")",
"if",
"all_effect_lists",
":",
"# Merge all effects from all effect_lists with a union merge.",
"self",
".",
"_effect_list",
"=",
"list",
"(",
"set",
"(",
")",
".",
"union",
"(",
"*",
"all_effect_lists",
")",
")",
"self",
".",
"_effect",
"=",
"None",
"all_effects",
"=",
"list",
"(",
"_find_state_attributes",
"(",
"on_states",
",",
"ATTR_EFFECT",
")",
")",
"if",
"all_effects",
":",
"# Report the most common effect.",
"effects_count",
"=",
"Counter",
"(",
"itertools",
".",
"chain",
"(",
"all_effects",
")",
")",
"self",
".",
"_effect",
"=",
"effects_count",
".",
"most_common",
"(",
"1",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"self",
".",
"_supported_features",
"=",
"0",
"for",
"support",
"in",
"_find_state_attributes",
"(",
"states",
",",
"ATTR_SUPPORTED_FEATURES",
")",
":",
"# Merge supported features by emulating support for every feature",
"# we find.",
"self",
".",
"_supported_features",
"|=",
"support",
"# Bitwise-and the supported features with the GroupedLight's features",
"# so that we don't break in the future when a new feature is added.",
"self",
".",
"_supported_features",
"&=",
"SUPPORT_GROUP_LIGHT"
] | [
288,
4
] | [
331,
55
] | python | en | ['en', 'en', 'en'] | True |
verify_ebusd_config | (config) | Verify eBusd config. | Verify eBusd config. | def verify_ebusd_config(config):
"""Verify eBusd config."""
circuit = config[CONF_CIRCUIT]
for condition in config[CONF_MONITORED_CONDITIONS]:
if condition not in SENSOR_TYPES[circuit]:
raise vol.Invalid(f"Condition '{condition}' not in '{circuit}'.")
return config | [
"def",
"verify_ebusd_config",
"(",
"config",
")",
":",
"circuit",
"=",
"config",
"[",
"CONF_CIRCUIT",
"]",
"for",
"condition",
"in",
"config",
"[",
"CONF_MONITORED_CONDITIONS",
"]",
":",
"if",
"condition",
"not",
"in",
"SENSOR_TYPES",
"[",
"circuit",
"]",
":",
"raise",
"vol",
".",
"Invalid",
"(",
"f\"Condition '{condition}' not in '{circuit}'.\"",
")",
"return",
"config"
] | [
27,
0
] | [
33,
17
] | python | en | ['en', 'pt', 'it'] | False |
setup | (hass, config) | Set up the eBusd component. | Set up the eBusd component. | def setup(hass, config):
"""Set up the eBusd component."""
_LOGGER.debug("Integration setup started")
conf = config[DOMAIN]
name = conf[CONF_NAME]
circuit = conf[CONF_CIRCUIT]
monitored_conditions = conf.get(CONF_MONITORED_CONDITIONS)
server_address = (conf.get(CONF_HOST), conf.get(CONF_PORT))
try:
ebusdpy.init(server_address)
hass.data[DOMAIN] = EbusdData(server_address, circuit)
sensor_config = {
CONF_MONITORED_CONDITIONS: monitored_conditions,
"client_name": name,
"sensor_types": SENSOR_TYPES[circuit],
}
load_platform(hass, "sensor", DOMAIN, sensor_config, config)
hass.services.register(DOMAIN, SERVICE_EBUSD_WRITE, hass.data[DOMAIN].write)
_LOGGER.debug("Ebusd integration setup completed")
return True
except (socket.timeout, OSError):
return False | [
"def",
"setup",
"(",
"hass",
",",
"config",
")",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Integration setup started\"",
")",
"conf",
"=",
"config",
"[",
"DOMAIN",
"]",
"name",
"=",
"conf",
"[",
"CONF_NAME",
"]",
"circuit",
"=",
"conf",
"[",
"CONF_CIRCUIT",
"]",
"monitored_conditions",
"=",
"conf",
".",
"get",
"(",
"CONF_MONITORED_CONDITIONS",
")",
"server_address",
"=",
"(",
"conf",
".",
"get",
"(",
"CONF_HOST",
")",
",",
"conf",
".",
"get",
"(",
"CONF_PORT",
")",
")",
"try",
":",
"ebusdpy",
".",
"init",
"(",
"server_address",
")",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"=",
"EbusdData",
"(",
"server_address",
",",
"circuit",
")",
"sensor_config",
"=",
"{",
"CONF_MONITORED_CONDITIONS",
":",
"monitored_conditions",
",",
"\"client_name\"",
":",
"name",
",",
"\"sensor_types\"",
":",
"SENSOR_TYPES",
"[",
"circuit",
"]",
",",
"}",
"load_platform",
"(",
"hass",
",",
"\"sensor\"",
",",
"DOMAIN",
",",
"sensor_config",
",",
"config",
")",
"hass",
".",
"services",
".",
"register",
"(",
"DOMAIN",
",",
"SERVICE_EBUSD_WRITE",
",",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
".",
"write",
")",
"_LOGGER",
".",
"debug",
"(",
"\"Ebusd integration setup completed\"",
")",
"return",
"True",
"except",
"(",
"socket",
".",
"timeout",
",",
"OSError",
")",
":",
"return",
"False"
] | [
55,
0
] | [
81,
20
] | python | en | ['en', 'en', 'en'] | True |
EbusdData.__init__ | (self, address, circuit) | Initialize the data object. | Initialize the data object. | def __init__(self, address, circuit):
"""Initialize the data object."""
self._circuit = circuit
self._address = address
self.value = {} | [
"def",
"__init__",
"(",
"self",
",",
"address",
",",
"circuit",
")",
":",
"self",
".",
"_circuit",
"=",
"circuit",
"self",
".",
"_address",
"=",
"address",
"self",
".",
"value",
"=",
"{",
"}"
] | [
87,
4
] | [
91,
23
] | python | en | ['en', 'en', 'en'] | True |
EbusdData.update | (self, name, stype) | Call the Ebusd API to update the data. | Call the Ebusd API to update the data. | def update(self, name, stype):
"""Call the Ebusd API to update the data."""
try:
_LOGGER.debug("Opening socket to ebusd %s", name)
command_result = ebusdpy.read(
self._address, self._circuit, name, stype, CACHE_TTL
)
if command_result is not None:
if "ERR:" in command_result:
_LOGGER.warning(command_result)
else:
self.value[name] = command_result
except RuntimeError as err:
_LOGGER.error(err)
raise RuntimeError(err) from err | [
"def",
"update",
"(",
"self",
",",
"name",
",",
"stype",
")",
":",
"try",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Opening socket to ebusd %s\"",
",",
"name",
")",
"command_result",
"=",
"ebusdpy",
".",
"read",
"(",
"self",
".",
"_address",
",",
"self",
".",
"_circuit",
",",
"name",
",",
"stype",
",",
"CACHE_TTL",
")",
"if",
"command_result",
"is",
"not",
"None",
":",
"if",
"\"ERR:\"",
"in",
"command_result",
":",
"_LOGGER",
".",
"warning",
"(",
"command_result",
")",
"else",
":",
"self",
".",
"value",
"[",
"name",
"]",
"=",
"command_result",
"except",
"RuntimeError",
"as",
"err",
":",
"_LOGGER",
".",
"error",
"(",
"err",
")",
"raise",
"RuntimeError",
"(",
"err",
")",
"from",
"err"
] | [
93,
4
] | [
107,
44
] | python | en | ['en', 'mi', 'en'] | True |
EbusdData.write | (self, call) | Call write methon on ebusd. | Call write methon on ebusd. | def write(self, call):
"""Call write methon on ebusd."""
name = call.data.get("name")
value = call.data.get("value")
try:
_LOGGER.debug("Opening socket to ebusd %s", name)
command_result = ebusdpy.write(self._address, self._circuit, name, value)
if command_result is not None:
if "done" not in command_result:
_LOGGER.warning("Write command failed: %s", name)
except RuntimeError as err:
_LOGGER.error(err) | [
"def",
"write",
"(",
"self",
",",
"call",
")",
":",
"name",
"=",
"call",
".",
"data",
".",
"get",
"(",
"\"name\"",
")",
"value",
"=",
"call",
".",
"data",
".",
"get",
"(",
"\"value\"",
")",
"try",
":",
"_LOGGER",
".",
"debug",
"(",
"\"Opening socket to ebusd %s\"",
",",
"name",
")",
"command_result",
"=",
"ebusdpy",
".",
"write",
"(",
"self",
".",
"_address",
",",
"self",
".",
"_circuit",
",",
"name",
",",
"value",
")",
"if",
"command_result",
"is",
"not",
"None",
":",
"if",
"\"done\"",
"not",
"in",
"command_result",
":",
"_LOGGER",
".",
"warning",
"(",
"\"Write command failed: %s\"",
",",
"name",
")",
"except",
"RuntimeError",
"as",
"err",
":",
"_LOGGER",
".",
"error",
"(",
"err",
")"
] | [
109,
4
] | [
121,
30
] | python | en | ['en', 'mi', 'nl'] | False |
test_setup_component | (hass) | Simple test setup of component. | Simple test setup of component. | async def test_setup_component(hass):
"""Simple test setup of component."""
result = await async_setup_component(hass, geo_location.DOMAIN, {})
assert result | [
"async",
"def",
"test_setup_component",
"(",
"hass",
")",
":",
"result",
"=",
"await",
"async_setup_component",
"(",
"hass",
",",
"geo_location",
".",
"DOMAIN",
",",
"{",
"}",
")",
"assert",
"result"
] | [
8,
0
] | [
11,
17
] | python | en | ['en', 'en', 'en'] | True |
test_event | (hass) | Simple test of the geolocation event class. | Simple test of the geolocation event class. | async def test_event(hass):
"""Simple test of the geolocation event class."""
entity = GeolocationEvent()
assert entity.state is None
assert entity.distance is None
assert entity.latitude is None
assert entity.longitude is None
with pytest.raises(NotImplementedError):
assert entity.source is None | [
"async",
"def",
"test_event",
"(",
"hass",
")",
":",
"entity",
"=",
"GeolocationEvent",
"(",
")",
"assert",
"entity",
".",
"state",
"is",
"None",
"assert",
"entity",
".",
"distance",
"is",
"None",
"assert",
"entity",
".",
"latitude",
"is",
"None",
"assert",
"entity",
".",
"longitude",
"is",
"None",
"with",
"pytest",
".",
"raises",
"(",
"NotImplementedError",
")",
":",
"assert",
"entity",
".",
"source",
"is",
"None"
] | [
14,
0
] | [
23,
36
] | python | en | ['en', 'en', 'en'] | True |
uniqify_urls | (soup, attr, slug) |
Change url(#some-id) references by prefixing the slug to the unique ID.
|
Change url(#some-id) references by prefixing the slug to the unique ID.
| def uniqify_urls(soup, attr, slug):
"""
Change url(#some-id) references by prefixing the slug to the unique ID.
"""
els = soup.find_all(attrs={attr: True})
for el in els:
if "url(#" in el[attr]:
el[attr] = el[attr].replace("url(#", "url(#"+slug) | [
"def",
"uniqify_urls",
"(",
"soup",
",",
"attr",
",",
"slug",
")",
":",
"els",
"=",
"soup",
".",
"find_all",
"(",
"attrs",
"=",
"{",
"attr",
":",
"True",
"}",
")",
"for",
"el",
"in",
"els",
":",
"if",
"\"url(#\"",
"in",
"el",
"[",
"attr",
"]",
":",
"el",
"[",
"attr",
"]",
"=",
"el",
"[",
"attr",
"]",
".",
"replace",
"(",
"\"url(#\"",
",",
"\"url(#\"",
"+",
"slug",
")"
] | [
12,
0
] | [
19,
62
] | python | en | ['en', 'error', 'th'] | False |
mock_healthybox | () | Mock fb.check_box_health. | Mock fb.check_box_health. | def mock_healthybox():
"""Mock fb.check_box_health."""
check_box_health = (
"homeassistant.components.facebox.image_processing.check_box_health"
)
with patch(check_box_health, return_value=MOCK_BOX_ID) as _mock_healthybox:
yield _mock_healthybox | [
"def",
"mock_healthybox",
"(",
")",
":",
"check_box_health",
"=",
"(",
"\"homeassistant.components.facebox.image_processing.check_box_health\"",
")",
"with",
"patch",
"(",
"check_box_health",
",",
"return_value",
"=",
"MOCK_BOX_ID",
")",
"as",
"_mock_healthybox",
":",
"yield",
"_mock_healthybox"
] | [
80,
0
] | [
86,
30
] | python | en | ['en', 'fil', 'en'] | False |
mock_isfile | () | Mock os.path.isfile. | Mock os.path.isfile. | def mock_isfile():
"""Mock os.path.isfile."""
with patch(
"homeassistant.components.facebox.image_processing.cv.isfile", return_value=True
) as _mock_isfile:
yield _mock_isfile | [
"def",
"mock_isfile",
"(",
")",
":",
"with",
"patch",
"(",
"\"homeassistant.components.facebox.image_processing.cv.isfile\"",
",",
"return_value",
"=",
"True",
")",
"as",
"_mock_isfile",
":",
"yield",
"_mock_isfile"
] | [
90,
0
] | [
95,
26
] | python | en | ['en', 'sm', 'en'] | False |
mock_image | () | Return a mock camera image. | Return a mock camera image. | def mock_image():
"""Return a mock camera image."""
with patch(
"homeassistant.components.demo.camera.DemoCamera.camera_image",
return_value=b"Test",
) as image:
yield image | [
"def",
"mock_image",
"(",
")",
":",
"with",
"patch",
"(",
"\"homeassistant.components.demo.camera.DemoCamera.camera_image\"",
",",
"return_value",
"=",
"b\"Test\"",
",",
")",
"as",
"image",
":",
"yield",
"image"
] | [
99,
0
] | [
105,
19
] | python | da | ['es', 'da', 'en'] | False |
test_check_box_health | (caplog) | Test check box health. | Test check box health. | def test_check_box_health(caplog):
"""Test check box health."""
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/healthz"
mock_req.get(url, status_code=HTTP_OK, json=MOCK_HEALTH)
assert fb.check_box_health(url, "user", "pass") == MOCK_BOX_ID
mock_req.get(url, status_code=HTTP_UNAUTHORIZED)
assert fb.check_box_health(url, None, None) is None
assert "AuthenticationError on facebox" in caplog.text
mock_req.get(url, exc=requests.exceptions.ConnectTimeout)
fb.check_box_health(url, None, None)
assert "ConnectionError: Is facebox running?" in caplog.text | [
"def",
"test_check_box_health",
"(",
"caplog",
")",
":",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/healthz\"",
"mock_req",
".",
"get",
"(",
"url",
",",
"status_code",
"=",
"HTTP_OK",
",",
"json",
"=",
"MOCK_HEALTH",
")",
"assert",
"fb",
".",
"check_box_health",
"(",
"url",
",",
"\"user\"",
",",
"\"pass\"",
")",
"==",
"MOCK_BOX_ID",
"mock_req",
".",
"get",
"(",
"url",
",",
"status_code",
"=",
"HTTP_UNAUTHORIZED",
")",
"assert",
"fb",
".",
"check_box_health",
"(",
"url",
",",
"None",
",",
"None",
")",
"is",
"None",
"assert",
"\"AuthenticationError on facebox\"",
"in",
"caplog",
".",
"text",
"mock_req",
".",
"get",
"(",
"url",
",",
"exc",
"=",
"requests",
".",
"exceptions",
".",
"ConnectTimeout",
")",
"fb",
".",
"check_box_health",
"(",
"url",
",",
"None",
",",
"None",
")",
"assert",
"\"ConnectionError: Is facebox running?\"",
"in",
"caplog",
".",
"text"
] | [
118,
0
] | [
131,
68
] | python | en | ['it', 'gd', 'en'] | False |
test_encode_image | () | Test that binary data is encoded correctly. | Test that binary data is encoded correctly. | def test_encode_image():
"""Test that binary data is encoded correctly."""
assert fb.encode_image(b"test") == "dGVzdA==" | [
"def",
"test_encode_image",
"(",
")",
":",
"assert",
"fb",
".",
"encode_image",
"(",
"b\"test\"",
")",
"==",
"\"dGVzdA==\""
] | [
134,
0
] | [
136,
49
] | python | en | ['en', 'en', 'en'] | True |
test_get_matched_faces | () | Test that matched_faces are parsed correctly. | Test that matched_faces are parsed correctly. | def test_get_matched_faces():
"""Test that matched_faces are parsed correctly."""
assert fb.get_matched_faces(PARSED_FACES) == MATCHED_FACES | [
"def",
"test_get_matched_faces",
"(",
")",
":",
"assert",
"fb",
".",
"get_matched_faces",
"(",
"PARSED_FACES",
")",
"==",
"MATCHED_FACES"
] | [
139,
0
] | [
141,
62
] | python | en | ['en', 'en', 'en'] | True |
test_parse_faces | () | Test parsing of raw face data, and generation of matched_faces. | Test parsing of raw face data, and generation of matched_faces. | def test_parse_faces():
"""Test parsing of raw face data, and generation of matched_faces."""
assert fb.parse_faces(MOCK_JSON["faces"]) == PARSED_FACES | [
"def",
"test_parse_faces",
"(",
")",
":",
"assert",
"fb",
".",
"parse_faces",
"(",
"MOCK_JSON",
"[",
"\"faces\"",
"]",
")",
"==",
"PARSED_FACES"
] | [
144,
0
] | [
146,
61
] | python | en | ['en', 'en', 'en'] | True |
test_valid_file_path | () | Test that an invalid file_path is caught. | Test that an invalid file_path is caught. | def test_valid_file_path():
"""Test that an invalid file_path is caught."""
assert not fb.valid_file_path("test_path") | [
"def",
"test_valid_file_path",
"(",
")",
":",
"assert",
"not",
"fb",
".",
"valid_file_path",
"(",
"\"test_path\"",
")"
] | [
150,
0
] | [
152,
46
] | python | en | ['en', 'en', 'en'] | True |
test_setup_platform | (hass, mock_healthybox) | Set up platform with one entity. | Set up platform with one entity. | async def test_setup_platform(hass, mock_healthybox):
"""Set up platform with one entity."""
await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
await hass.async_block_till_done()
assert hass.states.get(VALID_ENTITY_ID) | [
"async",
"def",
"test_setup_platform",
"(",
"hass",
",",
"mock_healthybox",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"VALID_CONFIG",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")"
] | [
155,
0
] | [
159,
43
] | python | en | ['en', 'en', 'en'] | True |
test_setup_platform_with_auth | (hass, mock_healthybox) | Set up platform with one entity and auth. | Set up platform with one entity and auth. | async def test_setup_platform_with_auth(hass, mock_healthybox):
"""Set up platform with one entity and auth."""
valid_config_auth = VALID_CONFIG.copy()
valid_config_auth[ip.DOMAIN][CONF_USERNAME] = MOCK_USERNAME
valid_config_auth[ip.DOMAIN][CONF_PASSWORD] = MOCK_PASSWORD
await async_setup_component(hass, ip.DOMAIN, valid_config_auth)
await hass.async_block_till_done()
assert hass.states.get(VALID_ENTITY_ID) | [
"async",
"def",
"test_setup_platform_with_auth",
"(",
"hass",
",",
"mock_healthybox",
")",
":",
"valid_config_auth",
"=",
"VALID_CONFIG",
".",
"copy",
"(",
")",
"valid_config_auth",
"[",
"ip",
".",
"DOMAIN",
"]",
"[",
"CONF_USERNAME",
"]",
"=",
"MOCK_USERNAME",
"valid_config_auth",
"[",
"ip",
".",
"DOMAIN",
"]",
"[",
"CONF_PASSWORD",
"]",
"=",
"MOCK_PASSWORD",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"valid_config_auth",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")"
] | [
162,
0
] | [
170,
43
] | python | en | ['en', 'en', 'en'] | True |
test_process_image | (hass, mock_healthybox, mock_image) | Test successful processing of an image. | Test successful processing of an image. | async def test_process_image(hass, mock_healthybox, mock_image):
"""Test successful processing of an image."""
await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
await hass.async_block_till_done()
assert hass.states.get(VALID_ENTITY_ID)
face_events = []
@callback
def mock_face_event(event):
"""Mock event."""
face_events.append(event)
hass.bus.async_listen("image_processing.detect_face", mock_face_event)
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/check"
mock_req.post(url, json=MOCK_JSON)
data = {ATTR_ENTITY_ID: VALID_ENTITY_ID}
await hass.services.async_call(ip.DOMAIN, ip.SERVICE_SCAN, service_data=data)
await hass.async_block_till_done()
state = hass.states.get(VALID_ENTITY_ID)
assert state.state == "1"
assert state.attributes.get("matched_faces") == MATCHED_FACES
assert state.attributes.get("total_matched_faces") == 1
PARSED_FACES[0][ATTR_ENTITY_ID] = VALID_ENTITY_ID # Update.
assert state.attributes.get("faces") == PARSED_FACES
assert state.attributes.get(CONF_FRIENDLY_NAME) == "facebox demo_camera"
assert len(face_events) == 1
assert face_events[0].data[ATTR_NAME] == PARSED_FACES[0][ATTR_NAME]
assert (
face_events[0].data[fb.ATTR_CONFIDENCE] == PARSED_FACES[0][fb.ATTR_CONFIDENCE]
)
assert face_events[0].data[ATTR_ENTITY_ID] == VALID_ENTITY_ID
assert face_events[0].data[fb.ATTR_IMAGE_ID] == PARSED_FACES[0][fb.ATTR_IMAGE_ID]
assert (
face_events[0].data[fb.ATTR_BOUNDING_BOX]
== PARSED_FACES[0][fb.ATTR_BOUNDING_BOX]
) | [
"async",
"def",
"test_process_image",
"(",
"hass",
",",
"mock_healthybox",
",",
"mock_image",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"VALID_CONFIG",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")",
"face_events",
"=",
"[",
"]",
"@",
"callback",
"def",
"mock_face_event",
"(",
"event",
")",
":",
"\"\"\"Mock event.\"\"\"",
"face_events",
".",
"append",
"(",
"event",
")",
"hass",
".",
"bus",
".",
"async_listen",
"(",
"\"image_processing.detect_face\"",
",",
"mock_face_event",
")",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/check\"",
"mock_req",
".",
"post",
"(",
"url",
",",
"json",
"=",
"MOCK_JSON",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"ip",
".",
"DOMAIN",
",",
"ip",
".",
"SERVICE_SCAN",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"state",
"=",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")",
"assert",
"state",
".",
"state",
"==",
"\"1\"",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"\"matched_faces\"",
")",
"==",
"MATCHED_FACES",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"\"total_matched_faces\"",
")",
"==",
"1",
"PARSED_FACES",
"[",
"0",
"]",
"[",
"ATTR_ENTITY_ID",
"]",
"=",
"VALID_ENTITY_ID",
"# Update.",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"\"faces\"",
")",
"==",
"PARSED_FACES",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"CONF_FRIENDLY_NAME",
")",
"==",
"\"facebox demo_camera\"",
"assert",
"len",
"(",
"face_events",
")",
"==",
"1",
"assert",
"face_events",
"[",
"0",
"]",
".",
"data",
"[",
"ATTR_NAME",
"]",
"==",
"PARSED_FACES",
"[",
"0",
"]",
"[",
"ATTR_NAME",
"]",
"assert",
"(",
"face_events",
"[",
"0",
"]",
".",
"data",
"[",
"fb",
".",
"ATTR_CONFIDENCE",
"]",
"==",
"PARSED_FACES",
"[",
"0",
"]",
"[",
"fb",
".",
"ATTR_CONFIDENCE",
"]",
")",
"assert",
"face_events",
"[",
"0",
"]",
".",
"data",
"[",
"ATTR_ENTITY_ID",
"]",
"==",
"VALID_ENTITY_ID",
"assert",
"face_events",
"[",
"0",
"]",
".",
"data",
"[",
"fb",
".",
"ATTR_IMAGE_ID",
"]",
"==",
"PARSED_FACES",
"[",
"0",
"]",
"[",
"fb",
".",
"ATTR_IMAGE_ID",
"]",
"assert",
"(",
"face_events",
"[",
"0",
"]",
".",
"data",
"[",
"fb",
".",
"ATTR_BOUNDING_BOX",
"]",
"==",
"PARSED_FACES",
"[",
"0",
"]",
"[",
"fb",
".",
"ATTR_BOUNDING_BOX",
"]",
")"
] | [
173,
0
] | [
214,
5
] | python | en | ['en', 'en', 'en'] | True |
test_process_image_errors | (hass, mock_healthybox, mock_image, caplog) | Test process_image errors. | Test process_image errors. | async def test_process_image_errors(hass, mock_healthybox, mock_image, caplog):
"""Test process_image errors."""
await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
await hass.async_block_till_done()
assert hass.states.get(VALID_ENTITY_ID)
# Test connection error.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/check"
mock_req.register_uri("POST", url, exc=requests.exceptions.ConnectTimeout)
data = {ATTR_ENTITY_ID: VALID_ENTITY_ID}
await hass.services.async_call(ip.DOMAIN, ip.SERVICE_SCAN, service_data=data)
await hass.async_block_till_done()
assert "ConnectionError: Is facebox running?" in caplog.text
state = hass.states.get(VALID_ENTITY_ID)
assert state.state == STATE_UNKNOWN
assert state.attributes.get("faces") == []
assert state.attributes.get("matched_faces") == {}
# Now test with bad auth.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/check"
mock_req.register_uri("POST", url, status_code=HTTP_UNAUTHORIZED)
data = {ATTR_ENTITY_ID: VALID_ENTITY_ID}
await hass.services.async_call(ip.DOMAIN, ip.SERVICE_SCAN, service_data=data)
await hass.async_block_till_done()
assert "AuthenticationError on facebox" in caplog.text | [
"async",
"def",
"test_process_image_errors",
"(",
"hass",
",",
"mock_healthybox",
",",
"mock_image",
",",
"caplog",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"VALID_CONFIG",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")",
"# Test connection error.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/check\"",
"mock_req",
".",
"register_uri",
"(",
"\"POST\"",
",",
"url",
",",
"exc",
"=",
"requests",
".",
"exceptions",
".",
"ConnectTimeout",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"ip",
".",
"DOMAIN",
",",
"ip",
".",
"SERVICE_SCAN",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"\"ConnectionError: Is facebox running?\"",
"in",
"caplog",
".",
"text",
"state",
"=",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")",
"assert",
"state",
".",
"state",
"==",
"STATE_UNKNOWN",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"\"faces\"",
")",
"==",
"[",
"]",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"\"matched_faces\"",
")",
"==",
"{",
"}",
"# Now test with bad auth.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/check\"",
"mock_req",
".",
"register_uri",
"(",
"\"POST\"",
",",
"url",
",",
"status_code",
"=",
"HTTP_UNAUTHORIZED",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"ip",
".",
"DOMAIN",
",",
"ip",
".",
"SERVICE_SCAN",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"\"AuthenticationError on facebox\"",
"in",
"caplog",
".",
"text"
] | [
217,
0
] | [
244,
62
] | python | da | ['da', 'zh', 'en'] | False |
test_teach_service | (
hass, mock_healthybox, mock_image, mock_isfile, mock_open_file, caplog
) | Test teaching of facebox. | Test teaching of facebox. | async def test_teach_service(
hass, mock_healthybox, mock_image, mock_isfile, mock_open_file, caplog
):
"""Test teaching of facebox."""
await async_setup_component(hass, ip.DOMAIN, VALID_CONFIG)
await hass.async_block_till_done()
assert hass.states.get(VALID_ENTITY_ID)
# Patch out 'is_allowed_path' as the mock files aren't allowed
hass.config.is_allowed_path = Mock(return_value=True)
# Test successful teach.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach"
mock_req.post(url, status_code=HTTP_OK)
data = {
ATTR_ENTITY_ID: VALID_ENTITY_ID,
ATTR_NAME: MOCK_NAME,
fb.FILE_PATH: MOCK_FILE_PATH,
}
await hass.services.async_call(
fb.DOMAIN, fb.SERVICE_TEACH_FACE, service_data=data
)
await hass.async_block_till_done()
# Now test with bad auth.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach"
mock_req.post(url, status_code=HTTP_UNAUTHORIZED)
data = {
ATTR_ENTITY_ID: VALID_ENTITY_ID,
ATTR_NAME: MOCK_NAME,
fb.FILE_PATH: MOCK_FILE_PATH,
}
await hass.services.async_call(
fb.DOMAIN, fb.SERVICE_TEACH_FACE, service_data=data
)
await hass.async_block_till_done()
assert "AuthenticationError on facebox" in caplog.text
# Now test the failed teaching.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach"
mock_req.post(url, status_code=HTTP_BAD_REQUEST, text=MOCK_ERROR_NO_FACE)
data = {
ATTR_ENTITY_ID: VALID_ENTITY_ID,
ATTR_NAME: MOCK_NAME,
fb.FILE_PATH: MOCK_FILE_PATH,
}
await hass.services.async_call(
fb.DOMAIN, fb.SERVICE_TEACH_FACE, service_data=data
)
await hass.async_block_till_done()
assert MOCK_ERROR_NO_FACE in caplog.text
# Now test connection error.
with requests_mock.Mocker() as mock_req:
url = f"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach"
mock_req.post(url, exc=requests.exceptions.ConnectTimeout)
data = {
ATTR_ENTITY_ID: VALID_ENTITY_ID,
ATTR_NAME: MOCK_NAME,
fb.FILE_PATH: MOCK_FILE_PATH,
}
await hass.services.async_call(
fb.DOMAIN, fb.SERVICE_TEACH_FACE, service_data=data
)
await hass.async_block_till_done()
assert "ConnectionError: Is facebox running?" in caplog.text | [
"async",
"def",
"test_teach_service",
"(",
"hass",
",",
"mock_healthybox",
",",
"mock_image",
",",
"mock_isfile",
",",
"mock_open_file",
",",
"caplog",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"VALID_CONFIG",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"VALID_ENTITY_ID",
")",
"# Patch out 'is_allowed_path' as the mock files aren't allowed",
"hass",
".",
"config",
".",
"is_allowed_path",
"=",
"Mock",
"(",
"return_value",
"=",
"True",
")",
"# Test successful teach.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach\"",
"mock_req",
".",
"post",
"(",
"url",
",",
"status_code",
"=",
"HTTP_OK",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
",",
"ATTR_NAME",
":",
"MOCK_NAME",
",",
"fb",
".",
"FILE_PATH",
":",
"MOCK_FILE_PATH",
",",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"fb",
".",
"DOMAIN",
",",
"fb",
".",
"SERVICE_TEACH_FACE",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"# Now test with bad auth.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach\"",
"mock_req",
".",
"post",
"(",
"url",
",",
"status_code",
"=",
"HTTP_UNAUTHORIZED",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
",",
"ATTR_NAME",
":",
"MOCK_NAME",
",",
"fb",
".",
"FILE_PATH",
":",
"MOCK_FILE_PATH",
",",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"fb",
".",
"DOMAIN",
",",
"fb",
".",
"SERVICE_TEACH_FACE",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"\"AuthenticationError on facebox\"",
"in",
"caplog",
".",
"text",
"# Now test the failed teaching.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach\"",
"mock_req",
".",
"post",
"(",
"url",
",",
"status_code",
"=",
"HTTP_BAD_REQUEST",
",",
"text",
"=",
"MOCK_ERROR_NO_FACE",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
",",
"ATTR_NAME",
":",
"MOCK_NAME",
",",
"fb",
".",
"FILE_PATH",
":",
"MOCK_FILE_PATH",
",",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"fb",
".",
"DOMAIN",
",",
"fb",
".",
"SERVICE_TEACH_FACE",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"MOCK_ERROR_NO_FACE",
"in",
"caplog",
".",
"text",
"# Now test connection error.",
"with",
"requests_mock",
".",
"Mocker",
"(",
")",
"as",
"mock_req",
":",
"url",
"=",
"f\"http://{MOCK_IP}:{MOCK_PORT}/facebox/teach\"",
"mock_req",
".",
"post",
"(",
"url",
",",
"exc",
"=",
"requests",
".",
"exceptions",
".",
"ConnectTimeout",
")",
"data",
"=",
"{",
"ATTR_ENTITY_ID",
":",
"VALID_ENTITY_ID",
",",
"ATTR_NAME",
":",
"MOCK_NAME",
",",
"fb",
".",
"FILE_PATH",
":",
"MOCK_FILE_PATH",
",",
"}",
"await",
"hass",
".",
"services",
".",
"async_call",
"(",
"fb",
".",
"DOMAIN",
",",
"fb",
".",
"SERVICE_TEACH_FACE",
",",
"service_data",
"=",
"data",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"\"ConnectionError: Is facebox running?\"",
"in",
"caplog",
".",
"text"
] | [
247,
0
] | [
315,
68
] | python | en | ['en', 'jv', 'en'] | True |
test_setup_platform_with_name | (hass, mock_healthybox) | Set up platform with one entity and a name. | Set up platform with one entity and a name. | async def test_setup_platform_with_name(hass, mock_healthybox):
"""Set up platform with one entity and a name."""
named_entity_id = f"image_processing.{MOCK_NAME}"
valid_config_named = VALID_CONFIG.copy()
valid_config_named[ip.DOMAIN][ip.CONF_SOURCE][ip.CONF_NAME] = MOCK_NAME
await async_setup_component(hass, ip.DOMAIN, valid_config_named)
await hass.async_block_till_done()
assert hass.states.get(named_entity_id)
state = hass.states.get(named_entity_id)
assert state.attributes.get(CONF_FRIENDLY_NAME) == MOCK_NAME | [
"async",
"def",
"test_setup_platform_with_name",
"(",
"hass",
",",
"mock_healthybox",
")",
":",
"named_entity_id",
"=",
"f\"image_processing.{MOCK_NAME}\"",
"valid_config_named",
"=",
"VALID_CONFIG",
".",
"copy",
"(",
")",
"valid_config_named",
"[",
"ip",
".",
"DOMAIN",
"]",
"[",
"ip",
".",
"CONF_SOURCE",
"]",
"[",
"ip",
".",
"CONF_NAME",
"]",
"=",
"MOCK_NAME",
"await",
"async_setup_component",
"(",
"hass",
",",
"ip",
".",
"DOMAIN",
",",
"valid_config_named",
")",
"await",
"hass",
".",
"async_block_till_done",
"(",
")",
"assert",
"hass",
".",
"states",
".",
"get",
"(",
"named_entity_id",
")",
"state",
"=",
"hass",
".",
"states",
".",
"get",
"(",
"named_entity_id",
")",
"assert",
"state",
".",
"attributes",
".",
"get",
"(",
"CONF_FRIENDLY_NAME",
")",
"==",
"MOCK_NAME"
] | [
318,
0
] | [
329,
64
] | python | en | ['en', 'en', 'en'] | True |
setup_platform | (hass, config, add_entities, discovery_info=None) | Set up the Yeelight Sunflower Light platform. | Set up the Yeelight Sunflower Light platform. | def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Yeelight Sunflower Light platform."""
host = config.get(CONF_HOST)
hub = yeelightsunflower.Hub(host)
if not hub.available:
_LOGGER.error("Could not connect to Yeelight Sunflower hub")
return False
add_entities(SunflowerBulb(light) for light in hub.get_lights()) | [
"def",
"setup_platform",
"(",
"hass",
",",
"config",
",",
"add_entities",
",",
"discovery_info",
"=",
"None",
")",
":",
"host",
"=",
"config",
".",
"get",
"(",
"CONF_HOST",
")",
"hub",
"=",
"yeelightsunflower",
".",
"Hub",
"(",
"host",
")",
"if",
"not",
"hub",
".",
"available",
":",
"_LOGGER",
".",
"error",
"(",
"\"Could not connect to Yeelight Sunflower hub\"",
")",
"return",
"False",
"add_entities",
"(",
"SunflowerBulb",
"(",
"light",
")",
"for",
"light",
"in",
"hub",
".",
"get_lights",
"(",
")",
")"
] | [
25,
0
] | [
34,
68
] | python | en | ['en', 'ky', 'en'] | True |
SunflowerBulb.__init__ | (self, light) | Initialize a Yeelight Sunflower bulb. | Initialize a Yeelight Sunflower bulb. | def __init__(self, light):
"""Initialize a Yeelight Sunflower bulb."""
self._light = light
self._available = light.available
self._brightness = light.brightness
self._is_on = light.is_on
self._rgb_color = light.rgb_color
self._unique_id = light.zid | [
"def",
"__init__",
"(",
"self",
",",
"light",
")",
":",
"self",
".",
"_light",
"=",
"light",
"self",
".",
"_available",
"=",
"light",
".",
"available",
"self",
".",
"_brightness",
"=",
"light",
".",
"brightness",
"self",
".",
"_is_on",
"=",
"light",
".",
"is_on",
"self",
".",
"_rgb_color",
"=",
"light",
".",
"rgb_color",
"self",
".",
"_unique_id",
"=",
"light",
".",
"zid"
] | [
40,
4
] | [
47,
35
] | python | en | ['en', 'lb', 'en'] | True |
End of preview. Expand
in Dataset Viewer.
Docstring to code data
Dataset Summary
This dataset contains pairs of English text and code from multiple programming language pairs. Namely, text is paired with code snippets for: Python, Java, JavaScript, and Go. The data is curated via an automated filtering pipeline from source files within The Stack.
Supported Tasks
This dataset can be used to finetune models for code-to-text and/or text-to-code models, both on information retrieval or conditional generation settings.
Splits
DATA_SPLITS = {"python_gh", "java_gh", "javascript_gh", "go_gh"}
How to get the data with a given programming language
from datasets import load_dataset
def get_dataset(prog_lang):
test_data = load_dataset("blindsubmissions/GH_text2code", split=prog_lang)
return test_data
Dataset Structure
Data Instances
Each data instance corresponds to function/methods occurring in licensed files that compose The Stack. That is, files with permissive licences collected from GitHub.
Relevant Data Fields
- identifier (string): Function/method name.
- parameters (string): Function parameters.
- return_statement (string): Return statement if found during parsing.
- docstring (string): Complete docstring content.
- docstring_summary (string): Summary/processed docstring dropping args and return statements.
- function (string): Actual function/method content.
- argument_list (null): List of arguments.
- language (string): Programming language of the function.
- type (string): Return type if found during parsing.
Summary of data curation pipeline
- Filtering out repositories that appear in CodeSearchNet.
- Filtering the files that belong to the programming languages of interest.
- Pre-filtering the files that likely contain text in the natural languages of interest.
- AST parsing with Tree-sitter.
- Perform language identification of docstrings in the resulting set of functions/methods and select the ones classified as English via majority voting.
Social Impact of the dataset
This dataset is released with the aim to increase the availability of training data available to the NLP for code research community by providing text/code paired data. We expect this data to help enable more accurate information retrieval systems and text-to-code or code-to-text summarization.
As a subset of The Stack, this dataset inherits de-risking efforts carried out when that dataset was built, though we highlight risks exist and malicious use of the data could exist such as, for instance, to aid on creation of malicious code. We highlight however that this is a risk shared by any code dataset made openly available.
Moreover, we remark that the data may contain harmful or offensive language, which could be learned by models trained on it.
Discussion of Biases
The data is collected from GitHub and naturally occurring text on that platform. As a consequence, certain languages are more or less likely to contain well documented code and, as such, resulting data will not be uniformly represented in terms of their programing languages.
Known limitations
The dataset can be expanded to further improve its coverage. Moreover, we use text naturally occurring as comments or docstrings as opposed to human annotators. As such, resulting data will have high variance in terms of quality depending on practices of sub-communities of software developers. However, we remark that the task our evaluation dataset defines is reflective of what searching on a real codebase would look like. Finally, we note that some imbalance on data is observed due to the same reason since certain languages are more or less likely to contain well documented code.
Maintenance plan:
The data will be kept up to date by following The Stack releases. We should rerun our pipeline for every new release and add non-overlapping new content to both training and testing partitions of our data.
This is so that we carry over opt-out updates and include fresh repos.
Update plan:
- Cover all 6 programming languages from CodeSearchNet.
Licensing Information
M2CRB is a subset filtered and pre-processed from The Stack, a collection of source code from repositories with various licenses. Any use of all or part of the code gathered in M2CRB must abide by the terms of the original licenses.
- Downloads last month
- 245