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 list | start_point list | end_point list | language stringclasses 1 value | docstring_language stringlengths 2 7 | docstring_language_predictions stringlengths 18 23 | is_langid_reliable stringclasses 2 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
DysonFilterLifeSensor.state | (self) | Return filter life in hours. | Return filter life in hours. | def state(self):
"""Return filter life in hours."""
if self._device.state:
return int(self._device.state.filter_life)
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"state",
":",
"return",
"int",
"(",
"self",
".",
"_device",
".",
"state",
".",
"filter_life",
")",
"return",
"None"
] | [
136,
4
] | [
140,
19
] | python | en | ['en', 'en', 'en'] | True |
DysonCarbonFilterLifeSensor.__init__ | (self, device) | Create a new Dyson Carbon Filter Life sensor. | Create a new Dyson Carbon Filter Life sensor. | def __init__(self, device):
"""Create a new Dyson Carbon Filter Life sensor."""
super().__init__(device, "carbon_filter_state")
self._name = f"{self._device.name} Carbon Filter Remaining Life" | [
"def",
"__init__",
"(",
"self",
",",
"device",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"carbon_filter_state\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} Carbon Filter Remaining Life\""
] | [
146,
4
] | [
149,
72
] | python | en | ['en', 'gl', 'en'] | True |
DysonCarbonFilterLifeSensor.state | (self) | Return filter life remaining in percent. | Return filter life remaining in percent. | def state(self):
"""Return filter life remaining in percent."""
if self._device.state:
return int(self._device.state.carbon_filter_state)
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"state",
":",
"return",
"int",
"(",
"self",
".",
"_device",
".",
"state",
".",
"carbon_filter_state",
")",
"return",
"None"
] | [
152,
4
] | [
156,
19
] | python | en | ['it', 'en', 'en'] | True |
DysonHepaFilterLifeSensor.__init__ | (self, device, filter_type="HEPA") | Create a new Dyson Filter Life sensor. | Create a new Dyson Filter Life sensor. | def __init__(self, device, filter_type="HEPA"):
"""Create a new Dyson Filter Life sensor."""
super().__init__(device, "hepa_filter_state")
self._name = f"{self._device.name} {filter_type} Filter Remaining Life" | [
"def",
"__init__",
"(",
"self",
",",
"device",
",",
"filter_type",
"=",
"\"HEPA\"",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"hepa_filter_state\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} {filter_type} Filter Remaining Li... | [
162,
4
] | [
165,
79
] | python | en | ['en', 'gl', 'en'] | True |
DysonHepaFilterLifeSensor.state | (self) | Return filter life remaining in percent. | Return filter life remaining in percent. | def state(self):
"""Return filter life remaining in percent."""
if self._device.state:
return int(self._device.state.hepa_filter_state)
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"state",
":",
"return",
"int",
"(",
"self",
".",
"_device",
".",
"state",
".",
"hepa_filter_state",
")",
"return",
"None"
] | [
168,
4
] | [
172,
19
] | python | en | ['it', 'en', 'en'] | True |
DysonDustSensor.__init__ | (self, device) | Create a new Dyson Dust sensor. | Create a new Dyson Dust sensor. | def __init__(self, device):
"""Create a new Dyson Dust sensor."""
super().__init__(device, "dust")
self._name = f"{self._device.name} Dust" | [
"def",
"__init__",
"(",
"self",
",",
"device",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"dust\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} Dust\""
] | [
178,
4
] | [
181,
48
] | python | en | ['en', 'ga', 'en'] | True |
DysonDustSensor.state | (self) | Return Dust value. | Return Dust value. | def state(self):
"""Return Dust value."""
if self._device.environmental_state:
return self._device.environmental_state.dust
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"environmental_state",
":",
"return",
"self",
".",
"_device",
".",
"environmental_state",
".",
"dust",
"return",
"None"
] | [
184,
4
] | [
188,
19
] | python | en | ['en', 'no', 'en'] | True |
DysonHumiditySensor.__init__ | (self, device) | Create a new Dyson Humidity sensor. | Create a new Dyson Humidity sensor. | def __init__(self, device):
"""Create a new Dyson Humidity sensor."""
super().__init__(device, "humidity")
self._name = f"{self._device.name} Humidity" | [
"def",
"__init__",
"(",
"self",
",",
"device",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"humidity\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} Humidity\""
] | [
194,
4
] | [
197,
52
] | python | en | ['en', 'mg', 'en'] | True |
DysonHumiditySensor.state | (self) | Return Humidity value. | Return Humidity value. | def state(self):
"""Return Humidity value."""
if self._device.environmental_state:
if self._device.environmental_state.humidity == 0:
return STATE_OFF
return self._device.environmental_state.humidity
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"environmental_state",
":",
"if",
"self",
".",
"_device",
".",
"environmental_state",
".",
"humidity",
"==",
"0",
":",
"return",
"STATE_OFF",
"return",
"self",
".",
"_device",
".",
... | [
200,
4
] | [
206,
19
] | python | en | ['en', 'et', 'en'] | True |
DysonTemperatureSensor.__init__ | (self, device, unit) | Create a new Dyson Temperature sensor. | Create a new Dyson Temperature sensor. | def __init__(self, device, unit):
"""Create a new Dyson Temperature sensor."""
super().__init__(device, "temperature")
self._name = f"{self._device.name} Temperature"
self._unit = unit | [
"def",
"__init__",
"(",
"self",
",",
"device",
",",
"unit",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"temperature\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} Temperature\"",
"self",
".",
"_unit",
"=",
"unit"
] | [
212,
4
] | [
216,
25
] | python | en | ['en', 'it', 'en'] | True |
DysonTemperatureSensor.state | (self) | Return Temperature value. | Return Temperature value. | def state(self):
"""Return Temperature value."""
if self._device.environmental_state:
temperature_kelvin = self._device.environmental_state.temperature
if temperature_kelvin == 0:
return STATE_OFF
if self._unit == TEMP_CELSIUS:
return float(f"{(temperature_kelvin - 273.15):.1f}")
return float(f"{(temperature_kelvin * 9 / 5 - 459.67):.1f}")
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"environmental_state",
":",
"temperature_kelvin",
"=",
"self",
".",
"_device",
".",
"environmental_state",
".",
"temperature",
"if",
"temperature_kelvin",
"==",
"0",
":",
"return",
"STAT... | [
219,
4
] | [
228,
19
] | python | en | ['en', 'la', 'en'] | True |
DysonTemperatureSensor.unit_of_measurement | (self) | Return the unit the value is expressed in. | Return the unit the value is expressed in. | def unit_of_measurement(self):
"""Return the unit the value is expressed in."""
return self._unit | [
"def",
"unit_of_measurement",
"(",
"self",
")",
":",
"return",
"self",
".",
"_unit"
] | [
231,
4
] | [
233,
25
] | python | en | ['en', 'en', 'en'] | True |
DysonAirQualitySensor.__init__ | (self, device) | Create a new Dyson Air Quality sensor. | Create a new Dyson Air Quality sensor. | def __init__(self, device):
"""Create a new Dyson Air Quality sensor."""
super().__init__(device, "air_quality")
self._name = f"{self._device.name} AQI" | [
"def",
"__init__",
"(",
"self",
",",
"device",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"device",
",",
"\"air_quality\"",
")",
"self",
".",
"_name",
"=",
"f\"{self._device.name} AQI\""
] | [
239,
4
] | [
242,
47
] | python | en | ['en', 'ga', 'en'] | True |
DysonAirQualitySensor.state | (self) | Return Air Quality value. | Return Air Quality value. | def state(self):
"""Return Air Quality value."""
if self._device.environmental_state:
return int(self._device.environmental_state.volatil_organic_compounds)
return None | [
"def",
"state",
"(",
"self",
")",
":",
"if",
"self",
".",
"_device",
".",
"environmental_state",
":",
"return",
"int",
"(",
"self",
".",
"_device",
".",
"environmental_state",
".",
"volatil_organic_compounds",
")",
"return",
"None"
] | [
245,
4
] | [
249,
19
] | python | en | ['en', 'gd', 'en'] | True |
async_describe_on_off_states | (
hass: HomeAssistantType, registry: GroupIntegrationRegistry
) | Describe group on off states. | Describe group on off states. | def async_describe_on_off_states(
hass: HomeAssistantType, registry: GroupIntegrationRegistry
) -> None:
"""Describe group on off states."""
registry.on_off_states({STATE_ON}, STATE_OFF) | [
"def",
"async_describe_on_off_states",
"(",
"hass",
":",
"HomeAssistantType",
",",
"registry",
":",
"GroupIntegrationRegistry",
")",
"->",
"None",
":",
"registry",
".",
"on_off_states",
"(",
"{",
"STATE_ON",
"}",
",",
"STATE_OFF",
")"
] | [
10,
0
] | [
14,
49
] | python | en | ['en', 'en', 'en'] | True |
conv2d | (x, W) | conv2d returns a 2d convolution layer with full stride. | conv2d returns a 2d convolution layer with full stride. | def conv2d(x, W):
"""conv2d returns a 2d convolution layer with full stride."""
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') | [
"def",
"conv2d",
"(",
"x",
",",
"W",
")",
":",
"return",
"tf",
".",
"nn",
".",
"conv2d",
"(",
"x",
",",
"W",
",",
"strides",
"=",
"[",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
",",
"padding",
"=",
"'SAME'",
")"
] | [
97,
0
] | [
99,
67
] | python | en | ['en', 'en', 'en'] | True |
max_pool | (x, pool_size) | max_pool downsamples a feature map by 2X. | max_pool downsamples a feature map by 2X. | def max_pool(x, pool_size):
"""max_pool downsamples a feature map by 2X."""
return tf.nn.max_pool(x, ksize=[1, pool_size, pool_size, 1], strides=[1,
pool_size, pool_size, 1], padding='SAME') | [
"def",
"max_pool",
"(",
"x",
",",
"pool_size",
")",
":",
"return",
"tf",
".",
"nn",
".",
"max_pool",
"(",
"x",
",",
"ksize",
"=",
"[",
"1",
",",
"pool_size",
",",
"pool_size",
",",
"1",
"]",
",",
"strides",
"=",
"[",
"1",
",",
"pool_size",
",",
... | [
102,
0
] | [
105,
49
] | python | en | ['en', 'en', 'en'] | True |
weight_variable | (shape) | weight_variable generates a weight variable of a given shape. | weight_variable generates a weight variable of a given shape. | def weight_variable(shape):
"""weight_variable generates a weight variable of a given shape."""
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial) | [
"def",
"weight_variable",
"(",
"shape",
")",
":",
"initial",
"=",
"tf",
".",
"truncated_normal",
"(",
"shape",
",",
"stddev",
"=",
"0.1",
")",
"return",
"tf",
".",
"Variable",
"(",
"initial",
")"
] | [
113,
0
] | [
116,
31
] | python | en | ['en', 'en', 'en'] | True |
bias_variable | (shape) | bias_variable generates a bias variable of a given shape. | bias_variable generates a bias variable of a given shape. | def bias_variable(shape):
"""bias_variable generates a bias variable of a given shape."""
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial) | [
"def",
"bias_variable",
"(",
"shape",
")",
":",
"initial",
"=",
"tf",
".",
"constant",
"(",
"0.1",
",",
"shape",
"=",
"shape",
")",
"return",
"tf",
".",
"Variable",
"(",
"initial",
")"
] | [
119,
0
] | [
122,
31
] | python | en | ['en', 'en', 'en'] | True |
mock_weather | () | Mock weather data. | Mock weather data. | def mock_weather():
"""Mock weather data."""
with patch("metno.MetWeatherData") as mock_data:
mock_data = mock_data.return_value
mock_data.fetching_data = AsyncMock(return_value=True)
mock_data.get_current_weather.return_value = {
"condition": "cloudy",
"temperature": 15,
"pressure": 100,
"humidity": 50,
"wind_speed": 10,
"wind_bearing": "NE",
}
mock_data.get_forecast.return_value = {}
yield mock_data | [
"def",
"mock_weather",
"(",
")",
":",
"with",
"patch",
"(",
"\"metno.MetWeatherData\"",
")",
"as",
"mock_data",
":",
"mock_data",
"=",
"mock_data",
".",
"return_value",
"mock_data",
".",
"fetching_data",
"=",
"AsyncMock",
"(",
"return_value",
"=",
"True",
")",
... | [
7,
0
] | [
21,
23
] | python | en | ['en', 'xh', 'en'] | True |
test_sending_location | (hass, create_registrations, webhook_client) | Test sending a location via a webhook. | Test sending a location via a webhook. | async def test_sending_location(hass, create_registrations, webhook_client):
"""Test sending a location via a webhook."""
resp = await webhook_client.post(
"/api/webhook/{}".format(create_registrations[1]["webhook_id"]),
json={
"type": "update_location",
"data": {
"gps": [10, 20],
"gps_accuracy": 30,
"battery": 40,
"altitude": 50,
"course": 60,
"speed": 70,
"vertical_accuracy": 80,
"location_name": "bar",
},
},
)
assert resp.status == 200
await hass.async_block_till_done()
state = hass.states.get("device_tracker.test_1_2")
assert state is not None
assert state.name == "Test 1"
assert state.state == "bar"
assert state.attributes["source_type"] == "gps"
assert state.attributes["latitude"] == 10
assert state.attributes["longitude"] == 20
assert state.attributes["gps_accuracy"] == 30
assert state.attributes["battery_level"] == 40
assert state.attributes["altitude"] == 50
assert state.attributes["course"] == 60
assert state.attributes["speed"] == 70
assert state.attributes["vertical_accuracy"] == 80
resp = await webhook_client.post(
"/api/webhook/{}".format(create_registrations[1]["webhook_id"]),
json={
"type": "update_location",
"data": {
"gps": [1, 2],
"gps_accuracy": 3,
"battery": 4,
"altitude": 5,
"course": 6,
"speed": 7,
"vertical_accuracy": 8,
},
},
)
assert resp.status == 200
await hass.async_block_till_done()
state = hass.states.get("device_tracker.test_1_2")
assert state is not None
assert state.state == "not_home"
assert state.attributes["source_type"] == "gps"
assert state.attributes["latitude"] == 1
assert state.attributes["longitude"] == 2
assert state.attributes["gps_accuracy"] == 3
assert state.attributes["battery_level"] == 4
assert state.attributes["altitude"] == 5
assert state.attributes["course"] == 6
assert state.attributes["speed"] == 7
assert state.attributes["vertical_accuracy"] == 8 | [
"async",
"def",
"test_sending_location",
"(",
"hass",
",",
"create_registrations",
",",
"webhook_client",
")",
":",
"resp",
"=",
"await",
"webhook_client",
".",
"post",
"(",
"\"/api/webhook/{}\"",
".",
"format",
"(",
"create_registrations",
"[",
"1",
"]",
"[",
"... | [
3,
0
] | [
67,
53
] | python | en | ['en', 'lb', 'en'] | True |
test_restoring_location | (hass, create_registrations, webhook_client) | Test sending a location via a webhook. | Test sending a location via a webhook. | async def test_restoring_location(hass, create_registrations, webhook_client):
"""Test sending a location via a webhook."""
resp = await webhook_client.post(
"/api/webhook/{}".format(create_registrations[1]["webhook_id"]),
json={
"type": "update_location",
"data": {
"gps": [10, 20],
"gps_accuracy": 30,
"battery": 40,
"altitude": 50,
"course": 60,
"speed": 70,
"vertical_accuracy": 80,
"location_name": "bar",
},
},
)
assert resp.status == 200
await hass.async_block_till_done()
state_1 = hass.states.get("device_tracker.test_1_2")
assert state_1 is not None
config_entry = hass.config_entries.async_entries("mobile_app")[1]
# mobile app doesn't support unloading, so we just reload device tracker
await hass.config_entries.async_forward_entry_unload(config_entry, "device_tracker")
await hass.config_entries.async_forward_entry_setup(config_entry, "device_tracker")
await hass.async_block_till_done()
state_2 = hass.states.get("device_tracker.test_1_2")
assert state_2 is not None
assert state_1 is not state_2
assert state_2.name == "Test 1"
assert state_2.attributes["source_type"] == "gps"
assert state_2.attributes["latitude"] == 10
assert state_2.attributes["longitude"] == 20
assert state_2.attributes["gps_accuracy"] == 30
assert state_2.attributes["battery_level"] == 40
assert state_2.attributes["altitude"] == 50
assert state_2.attributes["course"] == 60
assert state_2.attributes["speed"] == 70
assert state_2.attributes["vertical_accuracy"] == 80 | [
"async",
"def",
"test_restoring_location",
"(",
"hass",
",",
"create_registrations",
",",
"webhook_client",
")",
":",
"resp",
"=",
"await",
"webhook_client",
".",
"post",
"(",
"\"/api/webhook/{}\"",
".",
"format",
"(",
"create_registrations",
"[",
"1",
"]",
"[",
... | [
70,
0
] | [
114,
56
] | python | en | ['en', 'lb', 'en'] | True |
async_setup | (hass: HomeAssistantType, config: ConfigType) | Set up the Minecraft Server component. | Set up the Minecraft Server component. | async def async_setup(hass: HomeAssistantType, config: ConfigType) -> bool:
"""Set up the Minecraft Server component."""
return True | [
"async",
"def",
"async_setup",
"(",
"hass",
":",
"HomeAssistantType",
",",
"config",
":",
"ConfigType",
")",
"->",
"bool",
":",
"return",
"True"
] | [
28,
0
] | [
30,
15
] | python | en | ['en', 'en', 'en'] | True |
async_setup_entry | (hass: HomeAssistantType, config_entry: ConfigEntry) | Set up Minecraft Server from a config entry. | Set up Minecraft Server from a config entry. | async def async_setup_entry(hass: HomeAssistantType, config_entry: ConfigEntry) -> bool:
"""Set up Minecraft Server from a config entry."""
domain_data = hass.data.setdefault(DOMAIN, {})
# Create and store server instance.
unique_id = config_entry.unique_id
_LOGGER.debug(
"Creating server instance for '%s' (%s)",
config_entry.data[CONF_NAME],
config_entry.data[CONF_HOST],
)
server = MinecraftServer(hass, unique_id, config_entry.data)
domain_data[unique_id] = server
await server.async_update()
server.start_periodic_update()
# Set up platforms.
for platform in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, platform)
)
return True | [
"async",
"def",
"async_setup_entry",
"(",
"hass",
":",
"HomeAssistantType",
",",
"config_entry",
":",
"ConfigEntry",
")",
"->",
"bool",
":",
"domain_data",
"=",
"hass",
".",
"data",
".",
"setdefault",
"(",
"DOMAIN",
",",
"{",
"}",
")",
"# Create and store serv... | [
33,
0
] | [
55,
15
] | python | en | ['en', 'en', 'en'] | True |
async_unload_entry | (
hass: HomeAssistantType, config_entry: ConfigEntry
) | Unload Minecraft Server config entry. | Unload Minecraft Server config entry. | async def async_unload_entry(
hass: HomeAssistantType, config_entry: ConfigEntry
) -> bool:
"""Unload Minecraft Server config entry."""
unique_id = config_entry.unique_id
server = hass.data[DOMAIN][unique_id]
# Unload platforms.
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(config_entry, platform)
for platform in PLATFORMS
]
)
# Clean up.
server.stop_periodic_update()
hass.data[DOMAIN].pop(unique_id)
return True | [
"async",
"def",
"async_unload_entry",
"(",
"hass",
":",
"HomeAssistantType",
",",
"config_entry",
":",
"ConfigEntry",
")",
"->",
"bool",
":",
"unique_id",
"=",
"config_entry",
".",
"unique_id",
"server",
"=",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"[",
"un... | [
58,
0
] | [
77,
15
] | python | da | ['da', 'es', 'en'] | False |
MinecraftServer.__init__ | (
self, hass: HomeAssistantType, unique_id: str, config_data: ConfigType
) | Initialize server instance. | Initialize server instance. | def __init__(
self, hass: HomeAssistantType, unique_id: str, config_data: ConfigType
) -> None:
"""Initialize server instance."""
self._hass = hass
# Server data
self.unique_id = unique_id
self.name = config_data[CONF_NAME]
self.host = config_data[CONF_HOST]
self.port = config_data[CONF_PORT]
self.online = False
self._last_status_request_failed = False
self.srv_record_checked = False
# 3rd party library instance
self._mc_status = MCStatus(self.host, self.port)
# Data provided by 3rd party library
self.version = None
self.protocol_version = None
self.latency_time = None
self.players_online = None
self.players_max = None
self.players_list = None
# Dispatcher signal name
self.signal_name = f"{SIGNAL_NAME_PREFIX}_{self.unique_id}"
# Callback for stopping periodic update.
self._stop_periodic_update = None | [
"def",
"__init__",
"(",
"self",
",",
"hass",
":",
"HomeAssistantType",
",",
"unique_id",
":",
"str",
",",
"config_data",
":",
"ConfigType",
")",
"->",
"None",
":",
"self",
".",
"_hass",
"=",
"hass",
"# Server data",
"self",
".",
"unique_id",
"=",
"unique_i... | [
86,
4
] | [
116,
41
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServer.start_periodic_update | (self) | Start periodic execution of update method. | Start periodic execution of update method. | def start_periodic_update(self) -> None:
"""Start periodic execution of update method."""
self._stop_periodic_update = async_track_time_interval(
self._hass, self.async_update, timedelta(seconds=SCAN_INTERVAL)
) | [
"def",
"start_periodic_update",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_stop_periodic_update",
"=",
"async_track_time_interval",
"(",
"self",
".",
"_hass",
",",
"self",
".",
"async_update",
",",
"timedelta",
"(",
"seconds",
"=",
"SCAN_INTERVAL",
")",... | [
118,
4
] | [
122,
9
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServer.stop_periodic_update | (self) | Stop periodic execution of update method. | Stop periodic execution of update method. | def stop_periodic_update(self) -> None:
"""Stop periodic execution of update method."""
self._stop_periodic_update() | [
"def",
"stop_periodic_update",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_stop_periodic_update",
"(",
")"
] | [
124,
4
] | [
126,
36
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServer.async_check_connection | (self) | Check server connection using a 'status' request and store connection status. | Check server connection using a 'status' request and store connection status. | async def async_check_connection(self) -> None:
"""Check server connection using a 'status' request and store connection status."""
# Check if host is a valid SRV record, if not already done.
if not self.srv_record_checked:
self.srv_record_checked = True
srv_record = await helpers.async_check_srv_record(self._hass, self.host)
if srv_record is not None:
_LOGGER.debug(
"'%s' is a valid Minecraft SRV record ('%s:%s')",
self.host,
srv_record[CONF_HOST],
srv_record[CONF_PORT],
)
# Overwrite host, port and 3rd party library instance
# with data extracted out of SRV record.
self.host = srv_record[CONF_HOST]
self.port = srv_record[CONF_PORT]
self._mc_status = MCStatus(self.host, self.port)
# Ping the server with a status request.
try:
await self._hass.async_add_executor_job(
self._mc_status.status, self._MAX_RETRIES_STATUS
)
self.online = True
except OSError as error:
_LOGGER.debug(
"Error occurred while trying to check the connection to '%s:%s' - OSError: %s",
self.host,
self.port,
error,
)
self.online = False | [
"async",
"def",
"async_check_connection",
"(",
"self",
")",
"->",
"None",
":",
"# Check if host is a valid SRV record, if not already done.",
"if",
"not",
"self",
".",
"srv_record_checked",
":",
"self",
".",
"srv_record_checked",
"=",
"True",
"srv_record",
"=",
"await",... | [
128,
4
] | [
160,
31
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServer.async_update | (self, now: datetime = None) | Get server data from 3rd party library and update properties. | Get server data from 3rd party library and update properties. | async def async_update(self, now: datetime = None) -> None:
"""Get server data from 3rd party library and update properties."""
# Check connection status.
server_online_old = self.online
await self.async_check_connection()
server_online = self.online
# Inform user once about connection state changes if necessary.
if server_online_old and not server_online:
_LOGGER.warning("Connection to '%s:%s' lost", self.host, self.port)
elif not server_online_old and server_online:
_LOGGER.info("Connection to '%s:%s' (re-)established", self.host, self.port)
# Update the server properties if server is online.
if server_online:
await self._async_status_request()
# Notify sensors about new data.
async_dispatcher_send(self._hass, self.signal_name) | [
"async",
"def",
"async_update",
"(",
"self",
",",
"now",
":",
"datetime",
"=",
"None",
")",
"->",
"None",
":",
"# Check connection status.",
"server_online_old",
"=",
"self",
".",
"online",
"await",
"self",
".",
"async_check_connection",
"(",
")",
"server_online... | [
162,
4
] | [
180,
59
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServer._async_status_request | (self) | Request server status and update properties. | Request server status and update properties. | async def _async_status_request(self) -> None:
"""Request server status and update properties."""
try:
status_response = await self._hass.async_add_executor_job(
self._mc_status.status, self._MAX_RETRIES_STATUS
)
# Got answer to request, update properties.
self.version = status_response.version.name
self.protocol_version = status_response.version.protocol
self.players_online = status_response.players.online
self.players_max = status_response.players.max
self.latency_time = status_response.latency
self.players_list = []
if status_response.players.sample is not None:
for player in status_response.players.sample:
self.players_list.append(player.name)
self.players_list.sort()
# Inform user once about successful update if necessary.
if self._last_status_request_failed:
_LOGGER.info(
"Updating the properties of '%s:%s' succeeded again",
self.host,
self.port,
)
self._last_status_request_failed = False
except OSError as error:
# No answer to request, set all properties to unknown.
self.version = None
self.protocol_version = None
self.players_online = None
self.players_max = None
self.latency_time = None
self.players_list = None
# Inform user once about failed update if necessary.
if not self._last_status_request_failed:
_LOGGER.warning(
"Updating the properties of '%s:%s' failed - OSError: %s",
self.host,
self.port,
error,
)
self._last_status_request_failed = True | [
"async",
"def",
"_async_status_request",
"(",
"self",
")",
"->",
"None",
":",
"try",
":",
"status_response",
"=",
"await",
"self",
".",
"_hass",
".",
"async_add_executor_job",
"(",
"self",
".",
"_mc_status",
".",
"status",
",",
"self",
".",
"_MAX_RETRIES_STATU... | [
182,
4
] | [
226,
51
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServerEntity.__init__ | (
self, server: MinecraftServer, type_name: str, icon: str, device_class: str
) | Initialize base entity. | Initialize base entity. | def __init__(
self, server: MinecraftServer, type_name: str, icon: str, device_class: str
) -> None:
"""Initialize base entity."""
self._server = server
self._name = f"{server.name} {type_name}"
self._icon = icon
self._unique_id = f"{self._server.unique_id}-{type_name}"
self._device_info = {
"identifiers": {(DOMAIN, self._server.unique_id)},
"name": self._server.name,
"manufacturer": MANUFACTURER,
"model": f"Minecraft Server ({self._server.version})",
"sw_version": self._server.protocol_version,
}
self._device_class = device_class
self._device_state_attributes = None
self._disconnect_dispatcher = None | [
"def",
"__init__",
"(",
"self",
",",
"server",
":",
"MinecraftServer",
",",
"type_name",
":",
"str",
",",
"icon",
":",
"str",
",",
"device_class",
":",
"str",
")",
"->",
"None",
":",
"self",
".",
"_server",
"=",
"server",
"self",
".",
"_name",
"=",
"... | [
232,
4
] | [
249,
42
] | python | es | ['es', 'zu', 'it'] | False |
MinecraftServerEntity.name | (self) | Return name. | Return name. | def name(self) -> str:
"""Return name."""
return self._name | [
"def",
"name",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_name"
] | [
252,
4
] | [
254,
25
] | python | en | ['en', 'ig', 'en'] | False |
MinecraftServerEntity.unique_id | (self) | Return unique ID. | Return unique ID. | def unique_id(self) -> str:
"""Return unique ID."""
return self._unique_id | [
"def",
"unique_id",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_unique_id"
] | [
257,
4
] | [
259,
30
] | python | en | ['fr', 'la', 'en'] | False |
MinecraftServerEntity.device_info | (self) | Return device information. | Return device information. | def device_info(self) -> Dict[str, Any]:
"""Return device information."""
return self._device_info | [
"def",
"device_info",
"(",
"self",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"return",
"self",
".",
"_device_info"
] | [
262,
4
] | [
264,
32
] | python | da | ['es', 'da', 'en'] | False |
MinecraftServerEntity.device_class | (self) | Return device class. | Return device class. | def device_class(self) -> str:
"""Return device class."""
return self._device_class | [
"def",
"device_class",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_device_class"
] | [
267,
4
] | [
269,
33
] | python | en | ['es', 'zh', 'en'] | False |
MinecraftServerEntity.icon | (self) | Return icon. | Return icon. | def icon(self) -> str:
"""Return icon."""
return self._icon | [
"def",
"icon",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_icon"
] | [
272,
4
] | [
274,
25
] | python | en | ['en', 'la', 'en'] | False |
MinecraftServerEntity.should_poll | (self) | Disable polling. | Disable polling. | def should_poll(self) -> bool:
"""Disable polling."""
return False | [
"def",
"should_poll",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"False"
] | [
277,
4
] | [
279,
20
] | python | en | ['fr', 'en', 'en'] | False |
MinecraftServerEntity.async_update | (self) | Fetch data from the server. | Fetch data from the server. | async def async_update(self) -> None:
"""Fetch data from the server."""
raise NotImplementedError() | [
"async",
"def",
"async_update",
"(",
"self",
")",
"->",
"None",
":",
"raise",
"NotImplementedError",
"(",
")"
] | [
281,
4
] | [
283,
35
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServerEntity.async_added_to_hass | (self) | Connect dispatcher to signal from server. | Connect dispatcher to signal from server. | async def async_added_to_hass(self) -> None:
"""Connect dispatcher to signal from server."""
self._disconnect_dispatcher = async_dispatcher_connect(
self.hass, self._server.signal_name, self._update_callback
) | [
"async",
"def",
"async_added_to_hass",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_disconnect_dispatcher",
"=",
"async_dispatcher_connect",
"(",
"self",
".",
"hass",
",",
"self",
".",
"_server",
".",
"signal_name",
",",
"self",
".",
"_update_callback",
... | [
285,
4
] | [
289,
9
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServerEntity.async_will_remove_from_hass | (self) | Disconnect dispatcher before removal. | Disconnect dispatcher before removal. | async def async_will_remove_from_hass(self) -> None:
"""Disconnect dispatcher before removal."""
self._disconnect_dispatcher() | [
"async",
"def",
"async_will_remove_from_hass",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_disconnect_dispatcher",
"(",
")"
] | [
291,
4
] | [
293,
37
] | python | en | ['en', 'en', 'en'] | True |
MinecraftServerEntity._update_callback | (self) | Triggers update of properties after receiving signal from server. | Triggers update of properties after receiving signal from server. | def _update_callback(self) -> None:
"""Triggers update of properties after receiving signal from server."""
self.async_schedule_update_ha_state(force_refresh=True) | [
"def",
"_update_callback",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"async_schedule_update_ha_state",
"(",
"force_refresh",
"=",
"True",
")"
] | [
296,
4
] | [
298,
63
] | python | en | ['en', 'en', 'en'] | True |
pyorbit_polychord | (config_in, input_datasets=None, return_output=None) | A dummy file is created to let the cpulimit script to proceed with the next step | A dummy file is created to let the cpulimit script to proceed with the next step | def pyorbit_polychord(config_in, input_datasets=None, return_output=None):
output_directory = './' + config_in['output'] + '/polychord/'
mc = ModelContainerPolyChord()
pars_input(config_in, mc, input_datasets)
if mc.nested_sampling_parameters['shutdown_jitter']:
for dataset_name, dataset in mc.dataset_dict.items():
dataset.shutdown_jitter()
mc.model_setup()
mc.create_variables_bounds()
mc.initialize_logchi2()
mc.create_starting_point()
results_analysis.results_resumen(mc, None, skip_theta=True)
mc.output_directory = output_directory
# os.system("mkdir -p " + output_directory + "/clusters")
# os.system("mkdir -p " +output_directory + "chains/clusters")
print()
print('Reference Time Tref: ', mc.Tref)
print()
print('*************************************************************')
print()
settings = PolyChordSettings(nDims=mc.ndim, nDerived=0)
settings.file_root = 'pyorbit'
settings.base_dir = output_directory
for key_name, key_value in mc.nested_sampling_parameters.items():
if hasattr(settings, key_name):
setattr(settings, key_name, key_value)
if 'nlive_mult' in mc.nested_sampling_parameters:
setattr(settings, 'nlive', mc.ndim * mc.nested_sampling_parameters['nlive_mult'])
if 'num_repeats_mult' in mc.nested_sampling_parameters:
setattr(settings, 'num_repeats', mc.ndim * mc.nested_sampling_parameters['num_repeats_mult'])
if 'include_priors' in mc.nested_sampling_parameters:
mc.include_priors = mc.nested_sampling_parameters['include_priors']
output = pypolychord.run_polychord(mc.polychord_call, nDims=mc.ndim, nDerived=0, settings=settings,
prior=mc.polychord_priors, dumper=dumper)
paramnames = [('p%i' % i, r'\theta_%i' % i) for i in range(mc.ndim)]
paramnames += [('r*', 'r')]
output.make_paramnames_files(paramnames)
nested_sampling_save_to_cpickle(mc)
print()
print('PolyChord COMPLETED')
print()
""" A dummy file is created to let the cpulimit script to proceed with the next step"""
nested_sampling_create_dummy_file(mc)
if return_output:
return mc
else:
return | [
"def",
"pyorbit_polychord",
"(",
"config_in",
",",
"input_datasets",
"=",
"None",
",",
"return_output",
"=",
"None",
")",
":",
"output_directory",
"=",
"'./'",
"+",
"config_in",
"[",
"'output'",
"]",
"+",
"'/polychord/'",
"mc",
"=",
"ModelContainerPolyChord",
"(... | [
27,
0
] | [
94,
14
] | python | en | ['en', 'en', 'en'] | True |
async_get_engine | (hass, config, discovery_info=None) | Set up Google Cloud TTS component. | Set up Google Cloud TTS component. | async def async_get_engine(hass, config, discovery_info=None):
"""Set up Google Cloud TTS component."""
key_file = config.get(CONF_KEY_FILE)
if key_file:
key_file = hass.config.path(key_file)
if not os.path.isfile(key_file):
_LOGGER.error("File %s doesn't exist", key_file)
return None
return GoogleCloudTTSProvider(
hass,
key_file,
config.get(CONF_LANG),
config.get(CONF_GENDER),
config.get(CONF_VOICE),
config.get(CONF_ENCODING),
config.get(CONF_SPEED),
config.get(CONF_PITCH),
config.get(CONF_GAIN),
config.get(CONF_PROFILES),
) | [
"async",
"def",
"async_get_engine",
"(",
"hass",
",",
"config",
",",
"discovery_info",
"=",
"None",
")",
":",
"key_file",
"=",
"config",
".",
"get",
"(",
"CONF_KEY_FILE",
")",
"if",
"key_file",
":",
"key_file",
"=",
"hass",
".",
"config",
".",
"path",
"(... | [
134,
0
] | [
154,
5
] | python | en | ['en', 'ca', 'en'] | True |
GoogleCloudTTSProvider.__init__ | (
self,
hass,
key_file=None,
language=DEFAULT_LANG,
gender=DEFAULT_GENDER,
voice=DEFAULT_VOICE,
encoding=DEFAULT_ENCODING,
speed=1.0,
pitch=0,
gain=0,
profiles=None,
) | Init Google Cloud TTS service. | Init Google Cloud TTS service. | def __init__(
self,
hass,
key_file=None,
language=DEFAULT_LANG,
gender=DEFAULT_GENDER,
voice=DEFAULT_VOICE,
encoding=DEFAULT_ENCODING,
speed=1.0,
pitch=0,
gain=0,
profiles=None,
):
"""Init Google Cloud TTS service."""
self.hass = hass
self.name = "Google Cloud TTS"
self._language = language
self._gender = gender
self._voice = voice
self._encoding = encoding
self._speed = speed
self._pitch = pitch
self._gain = gain
self._profiles = profiles
if key_file:
self._client = texttospeech.TextToSpeechClient.from_service_account_json(
key_file
)
else:
self._client = texttospeech.TextToSpeechClient() | [
"def",
"__init__",
"(",
"self",
",",
"hass",
",",
"key_file",
"=",
"None",
",",
"language",
"=",
"DEFAULT_LANG",
",",
"gender",
"=",
"DEFAULT_GENDER",
",",
"voice",
"=",
"DEFAULT_VOICE",
",",
"encoding",
"=",
"DEFAULT_ENCODING",
",",
"speed",
"=",
"1.0",
"... | [
160,
4
] | [
190,
60
] | python | ca | ['nl', 'ca', 'en'] | False |
GoogleCloudTTSProvider.supported_languages | (self) | Return list of supported languages. | Return list of supported languages. | def supported_languages(self):
"""Return list of supported languages."""
return SUPPORTED_LANGUAGES | [
"def",
"supported_languages",
"(",
"self",
")",
":",
"return",
"SUPPORTED_LANGUAGES"
] | [
193,
4
] | [
195,
34
] | python | en | ['en', 'en', 'en'] | True |
GoogleCloudTTSProvider.default_language | (self) | Return the default language. | Return the default language. | def default_language(self):
"""Return the default language."""
return self._language | [
"def",
"default_language",
"(",
"self",
")",
":",
"return",
"self",
".",
"_language"
] | [
198,
4
] | [
200,
29
] | python | en | ['en', 'et', 'en'] | True |
GoogleCloudTTSProvider.supported_options | (self) | Return a list of supported options. | Return a list of supported options. | def supported_options(self):
"""Return a list of supported options."""
return SUPPORTED_OPTIONS | [
"def",
"supported_options",
"(",
"self",
")",
":",
"return",
"SUPPORTED_OPTIONS"
] | [
203,
4
] | [
205,
32
] | python | en | ['en', 'en', 'en'] | True |
GoogleCloudTTSProvider.default_options | (self) | Return a dict including default options. | Return a dict including default options. | def default_options(self):
"""Return a dict including default options."""
return {
CONF_GENDER: self._gender,
CONF_VOICE: self._voice,
CONF_ENCODING: self._encoding,
CONF_SPEED: self._speed,
CONF_PITCH: self._pitch,
CONF_GAIN: self._gain,
CONF_PROFILES: self._profiles,
} | [
"def",
"default_options",
"(",
"self",
")",
":",
"return",
"{",
"CONF_GENDER",
":",
"self",
".",
"_gender",
",",
"CONF_VOICE",
":",
"self",
".",
"_voice",
",",
"CONF_ENCODING",
":",
"self",
".",
"_encoding",
",",
"CONF_SPEED",
":",
"self",
".",
"_speed",
... | [
208,
4
] | [
218,
9
] | python | ca | ['id', 'ca', 'en'] | False |
GoogleCloudTTSProvider.async_get_tts_audio | (self, message, language, options=None) | Load TTS from google. | Load TTS from google. | async def async_get_tts_audio(self, message, language, options=None):
"""Load TTS from google."""
options_schema = vol.Schema(
{
vol.Optional(CONF_GENDER, default=self._gender): GENDER_SCHEMA,
vol.Optional(CONF_VOICE, default=self._voice): VOICE_SCHEMA,
vol.Optional(CONF_ENCODING, default=DEFAULT_ENCODING): SCHEMA_ENCODING,
vol.Optional(CONF_SPEED, default=self._speed): SPEED_SCHEMA,
vol.Optional(CONF_PITCH, default=self._speed): SPEED_SCHEMA,
vol.Optional(CONF_GAIN, default=DEFAULT_GAIN): GAIN_SCHEMA,
vol.Optional(CONF_PROFILES, default=[]): PROFILES_SCHEMA,
}
)
options = options_schema(options)
_encoding = options[CONF_ENCODING]
_voice = options[CONF_VOICE]
if _voice and not _voice.startswith(language):
language = _voice[:5]
try:
# pylint: disable=no-member
synthesis_input = texttospeech.types.SynthesisInput(text=message)
voice = texttospeech.types.VoiceSelectionParams(
language_code=language,
ssml_gender=texttospeech.enums.SsmlVoiceGender[options[CONF_GENDER]],
name=_voice,
)
audio_config = texttospeech.types.AudioConfig(
audio_encoding=texttospeech.enums.AudioEncoding[_encoding],
speaking_rate=options.get(CONF_SPEED),
pitch=options.get(CONF_PITCH),
volume_gain_db=options.get(CONF_GAIN),
effects_profile_id=options.get(CONF_PROFILES),
)
# pylint: enable=no-member
with async_timeout.timeout(10, loop=self.hass.loop):
response = await self.hass.async_add_executor_job(
self._client.synthesize_speech, synthesis_input, voice, audio_config
)
return _encoding, response.audio_content
except asyncio.TimeoutError as ex:
_LOGGER.error("Timeout for Google Cloud TTS call: %s", ex)
except Exception as ex: # pylint: disable=broad-except
_LOGGER.exception("Error occurred during Google Cloud TTS call: %s", ex)
return None, None | [
"async",
"def",
"async_get_tts_audio",
"(",
"self",
",",
"message",
",",
"language",
",",
"options",
"=",
"None",
")",
":",
"options_schema",
"=",
"vol",
".",
"Schema",
"(",
"{",
"vol",
".",
"Optional",
"(",
"CONF_GENDER",
",",
"default",
"=",
"self",
".... | [
220,
4
] | [
270,
25
] | python | en | ['en', '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",
")"
] | [
24,
0
] | [
26,
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",
")"
] | [
30,
0
] | [
32,
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\"",
")"
] | [
36,
0
] | [
38,
57
] | python | en | ['en', 'en', 'en'] | True |
test_get_conditions | (hass, device_reg, entity_reg) | Test we get the expected conditions from a vacuum. | Test we get the expected conditions from a vacuum. | async def test_get_conditions(hass, device_reg, entity_reg):
"""Test we get the expected conditions from a vacuum."""
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_conditions = [
{
"condition": "device",
"domain": DOMAIN,
"type": "is_cleaning",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
{
"condition": "device",
"domain": DOMAIN,
"type": "is_docked",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
]
conditions = await async_get_device_automations(hass, "condition", device_entry.id)
assert_lists_same(conditions, expected_conditions) | [
"async",
"def",
"test_get_conditions",
"(",
"hass",
",",
"device_reg",
",",
"entity_reg",
")",
":",
"config_entry",
"=",
"MockConfigEntry",
"(",
"domain",
"=",
"\"test\"",
",",
"data",
"=",
"{",
"}",
")",
"config_entry",
".",
"add_to_hass",
"(",
"hass",
")",... | [
41,
0
] | [
67,
54
] | python | en | ['en', 'en', 'en'] | True |
test_if_state | (hass, calls) | Test for turn_on and turn_off conditions. | Test for turn_on and turn_off conditions. | async def test_if_state(hass, calls):
"""Test for turn_on and turn_off conditions."""
hass.states.async_set("vacuum.entity", STATE_DOCKED)
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {"platform": "event", "event_type": "test_event1"},
"condition": [
{
"condition": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "vacuum.entity",
"type": "is_cleaning",
}
],
"action": {
"service": "test.automation",
"data_template": {
"some": "is_cleaning - {{ trigger.platform }} - {{ trigger.event.event_type }}"
},
},
},
{
"trigger": {"platform": "event", "event_type": "test_event2"},
"condition": [
{
"condition": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "vacuum.entity",
"type": "is_docked",
}
],
"action": {
"service": "test.automation",
"data_template": {
"some": "is_docked - {{ trigger.platform }} - {{ trigger.event.event_type }}"
},
},
},
]
},
)
hass.bus.async_fire("test_event1")
hass.bus.async_fire("test_event2")
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].data["some"] == "is_docked - event - test_event2"
hass.states.async_set("vacuum.entity", STATE_CLEANING)
hass.bus.async_fire("test_event1")
hass.bus.async_fire("test_event2")
await hass.async_block_till_done()
assert len(calls) == 2
assert calls[1].data["some"] == "is_cleaning - event - test_event1"
# Returning means it's still cleaning
hass.states.async_set("vacuum.entity", STATE_RETURNING)
hass.bus.async_fire("test_event1")
hass.bus.async_fire("test_event2")
await hass.async_block_till_done()
assert len(calls) == 3
assert calls[2].data["some"] == "is_cleaning - event - test_event1" | [
"async",
"def",
"test_if_state",
"(",
"hass",
",",
"calls",
")",
":",
"hass",
".",
"states",
".",
"async_set",
"(",
"\"vacuum.entity\"",
",",
"STATE_DOCKED",
")",
"assert",
"await",
"async_setup_component",
"(",
"hass",
",",
"automation",
".",
"DOMAIN",
",",
... | [
70,
0
] | [
137,
71
] | python | en | ['en', 'en', 'en'] | True |
RefCOCO.__init__ | (self, image_set, root_path, data_path, boxes='gt', proposal_source='official',
transform=None, test_mode=False,
zip_mode=False, cache_mode=False, cache_db=False, ignore_db_cache=True,
tokenizer=None, pretrained_model_name=None,
add_image_as_a_box=False, mask_size=(14, 14),
aspect_grouping=False, **kwargs) |
RefCOCO+ Dataset
:param image_set: image folder name
:param root_path: root path to cache database loaded from annotation file
:param data_path: path to dataset
:param boxes: boxes to use, 'gt' or 'proposal'
:param transform: transform
:param test_mode: test mode means no labels available
:param zip_mode: reading images and metadata in zip archive
:param cache_mode: cache whole dataset to RAM first, then __getitem__ read them from RAM
:param ignore_db_cache: ignore previous cached database, reload it from annotation file
:param tokenizer: default is BertTokenizer from pytorch_pretrained_bert
:param add_image_as_a_box: add whole image as a box
:param mask_size: size of instance mask of each object
:param aspect_grouping: whether to group images via their aspect
:param kwargs:
|
RefCOCO+ Dataset | def __init__(self, image_set, root_path, data_path, boxes='gt', proposal_source='official',
transform=None, test_mode=False,
zip_mode=False, cache_mode=False, cache_db=False, ignore_db_cache=True,
tokenizer=None, pretrained_model_name=None,
add_image_as_a_box=False, mask_size=(14, 14),
aspect_grouping=False, **kwargs):
"""
RefCOCO+ Dataset
:param image_set: image folder name
:param root_path: root path to cache database loaded from annotation file
:param data_path: path to dataset
:param boxes: boxes to use, 'gt' or 'proposal'
:param transform: transform
:param test_mode: test mode means no labels available
:param zip_mode: reading images and metadata in zip archive
:param cache_mode: cache whole dataset to RAM first, then __getitem__ read them from RAM
:param ignore_db_cache: ignore previous cached database, reload it from annotation file
:param tokenizer: default is BertTokenizer from pytorch_pretrained_bert
:param add_image_as_a_box: add whole image as a box
:param mask_size: size of instance mask of each object
:param aspect_grouping: whether to group images via their aspect
:param kwargs:
"""
super(RefCOCO, self).__init__()
assert not cache_mode, 'currently not support cache mode!'
categories = ['__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck',
'boat',
'trafficlight', 'firehydrant', 'stopsign', 'parkingmeter', 'bench', 'bird', 'cat', 'dog', 'horse',
'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',
'suitcase', 'frisbee', 'skis', 'snowboard', 'sportsball', 'kite', 'baseballbat', 'baseballglove',
'skateboard', 'surfboard', 'tennisracket', 'bottle', 'wineglass', 'cup', 'fork', 'knife', 'spoon',
'bowl', 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hotdog', 'pizza', 'donut',
'cake', 'chair', 'couch', 'pottedplant', 'bed', 'diningtable', 'toilet', 'tv', 'laptop', 'mouse',
'remote', 'keyboard', 'cellphone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book',
'clock', 'vase', 'scissors', 'teddybear', 'hairdrier', 'toothbrush']
coco_annot_files = {
"train2014": "annotations/instances_train2014.json",
"val2014": "annotations/instances_val2014.json",
"test2015": "annotations/image_info_test2015.json",
}
proposal_dets = 'refcoco+/proposal/res101_coco_minus_refer_notime_dets.json'
proposal_masks = 'refcoco+/proposal/res101_coco_minus_refer_notime_masks.json'
self.vg_proposal = ("vgbua_res101_precomputed", "trainval2014_resnet101_faster_rcnn_genome")
self.proposal_source = proposal_source
self.boxes = boxes
self.test_mode = test_mode
self.category_to_idx = {c: i for i, c in enumerate(categories)}
self.data_path = data_path
self.root_path = root_path
self.transform = transform
self.image_sets = [iset.strip() for iset in image_set.split('+')]
self.coco = COCO(annotation_file=os.path.join(data_path, coco_annot_files['train2014']))
self.refer = REFER(data_path, dataset='refcoco+', splitBy='unc')
self.refer_ids = []
for iset in self.image_sets:
self.refer_ids.extend(self.refer.getRefIds(split=iset))
self.refs = self.refer.loadRefs(ref_ids=self.refer_ids)
if 'proposal' in boxes:
with open(os.path.join(data_path, proposal_dets), 'r') as f:
proposal_list = json.load(f)
self.proposals = {}
for proposal in proposal_list:
image_id = proposal['image_id']
if image_id in self.proposals:
self.proposals[image_id].append(proposal['box'])
else:
self.proposals[image_id] = [proposal['box']]
self.zip_mode = zip_mode
self.cache_mode = cache_mode
self.cache_db = cache_db
self.ignore_db_cache = ignore_db_cache
self.aspect_grouping = aspect_grouping
self.cache_dir = os.path.join(root_path, 'cache')
self.add_image_as_a_box = add_image_as_a_box
self.mask_size = mask_size
if not os.path.exists(self.cache_dir):
makedirsExist(self.cache_dir)
self.tokenizer = tokenizer if tokenizer is not None \
else BertTokenizer.from_pretrained(
'bert-base-uncased' if pretrained_model_name is None else pretrained_model_name,
cache_dir=self.cache_dir)
if zip_mode:
self.zipreader = ZipReader()
self.database = self.load_annotations()
if self.aspect_grouping:
self.group_ids = self.group_aspect(self.database) | [
"def",
"__init__",
"(",
"self",
",",
"image_set",
",",
"root_path",
",",
"data_path",
",",
"boxes",
"=",
"'gt'",
",",
"proposal_source",
"=",
"'official'",
",",
"transform",
"=",
"None",
",",
"test_mode",
"=",
"False",
",",
"zip_mode",
"=",
"False",
",",
... | [
22,
4
] | [
113,
61
] | python | en | ['en', 'error', 'th'] | False |
create_influx_url | (conf: Dict) | Build URL used from config inputs and default when necessary. | Build URL used from config inputs and default when necessary. | def create_influx_url(conf: Dict) -> Dict:
"""Build URL used from config inputs and default when necessary."""
if conf[CONF_API_VERSION] == API_VERSION_2:
if CONF_SSL not in conf:
conf[CONF_SSL] = DEFAULT_SSL_V2
if CONF_HOST not in conf:
conf[CONF_HOST] = DEFAULT_HOST_V2
url = conf[CONF_HOST]
if conf[CONF_SSL]:
url = f"https://{url}"
else:
url = f"http://{url}"
if CONF_PORT in conf:
url = f"{url}:{conf[CONF_PORT]}"
if CONF_PATH in conf:
url = f"{url}{conf[CONF_PATH]}"
conf[CONF_URL] = url
return conf | [
"def",
"create_influx_url",
"(",
"conf",
":",
"Dict",
")",
"->",
"Dict",
":",
"if",
"conf",
"[",
"CONF_API_VERSION",
"]",
"==",
"API_VERSION_2",
":",
"if",
"CONF_SSL",
"not",
"in",
"conf",
":",
"conf",
"[",
"CONF_SSL",
"]",
"=",
"DEFAULT_SSL_V2",
"if",
"... | [
101,
0
] | [
123,
15
] | python | en | ['en', 'en', 'en'] | True |
validate_version_specific_config | (conf: Dict) | Ensure correct config fields are provided based on API version used. | Ensure correct config fields are provided based on API version used. | def validate_version_specific_config(conf: Dict) -> Dict:
"""Ensure correct config fields are provided based on API version used."""
if conf[CONF_API_VERSION] == API_VERSION_2:
if CONF_TOKEN not in conf:
raise vol.Invalid(
f"{CONF_TOKEN} and {CONF_BUCKET} are required when {CONF_API_VERSION} is {API_VERSION_2}"
)
if CONF_USERNAME in conf:
raise vol.Invalid(
f"{CONF_USERNAME} and {CONF_PASSWORD} are only allowed when {CONF_API_VERSION} is {DEFAULT_API_VERSION}"
)
else:
if CONF_TOKEN in conf:
raise vol.Invalid(
f"{CONF_TOKEN} and {CONF_BUCKET} are only allowed when {CONF_API_VERSION} is {API_VERSION_2}"
)
return conf | [
"def",
"validate_version_specific_config",
"(",
"conf",
":",
"Dict",
")",
"->",
"Dict",
":",
"if",
"conf",
"[",
"CONF_API_VERSION",
"]",
"==",
"API_VERSION_2",
":",
"if",
"CONF_TOKEN",
"not",
"in",
"conf",
":",
"raise",
"vol",
".",
"Invalid",
"(",
"f\"{CONF_... | [
126,
0
] | [
145,
15
] | python | en | ['en', 'en', 'en'] | True |
_generate_event_to_json | (conf: Dict) | Build event to json converter and add to config. | Build event to json converter and add to config. | def _generate_event_to_json(conf: Dict) -> Callable[[Dict], str]:
"""Build event to json converter and add to config."""
entity_filter = convert_include_exclude_filter(conf)
tags = conf.get(CONF_TAGS)
tags_attributes = conf.get(CONF_TAGS_ATTRIBUTES)
default_measurement = conf.get(CONF_DEFAULT_MEASUREMENT)
measurement_attr = conf.get(CONF_MEASUREMENT_ATTR)
override_measurement = conf.get(CONF_OVERRIDE_MEASUREMENT)
global_ignore_attributes = set(conf[CONF_IGNORE_ATTRIBUTES])
component_config = EntityValues(
conf[CONF_COMPONENT_CONFIG],
conf[CONF_COMPONENT_CONFIG_DOMAIN],
conf[CONF_COMPONENT_CONFIG_GLOB],
)
def event_to_json(event: Dict) -> str:
"""Convert event into json in format Influx expects."""
state = event.data.get(EVENT_NEW_STATE)
if (
state is None
or state.state in (STATE_UNKNOWN, "", STATE_UNAVAILABLE)
or not entity_filter(state.entity_id)
):
return
try:
_include_state = _include_value = False
_state_as_value = float(state.state)
_include_value = True
except ValueError:
try:
_state_as_value = float(state_helper.state_as_number(state))
_include_state = _include_value = True
except ValueError:
_include_state = True
include_uom = True
include_dc = True
entity_config = component_config.get(state.entity_id)
measurement = entity_config.get(CONF_OVERRIDE_MEASUREMENT)
if measurement in (None, ""):
if override_measurement:
measurement = override_measurement
else:
if measurement_attr == "entity_id":
measurement = state.entity_id
elif measurement_attr == "domain__device_class":
device_class = state.attributes.get("device_class")
if device_class is None:
# This entity doesn't have a device_class set, use only domain
measurement = state.domain
else:
measurement = f"{state.domain}__{device_class}"
include_dc = False
else:
measurement = state.attributes.get(measurement_attr)
if measurement in (None, ""):
if default_measurement:
measurement = default_measurement
else:
measurement = state.entity_id
else:
include_uom = measurement_attr != "unit_of_measurement"
json = {
INFLUX_CONF_MEASUREMENT: measurement,
INFLUX_CONF_TAGS: {
CONF_DOMAIN: state.domain,
CONF_ENTITY_ID: state.object_id,
},
INFLUX_CONF_TIME: event.time_fired,
INFLUX_CONF_FIELDS: {},
}
if _include_state:
json[INFLUX_CONF_FIELDS][INFLUX_CONF_STATE] = state.state
if _include_value:
json[INFLUX_CONF_FIELDS][INFLUX_CONF_VALUE] = _state_as_value
ignore_attributes = set(entity_config.get(CONF_IGNORE_ATTRIBUTES, []))
ignore_attributes.update(global_ignore_attributes)
for key, value in state.attributes.items():
if key in tags_attributes:
json[INFLUX_CONF_TAGS][key] = value
elif (
(key != CONF_UNIT_OF_MEASUREMENT or include_uom)
and (key != "device_class" or include_dc)
and key not in ignore_attributes
):
# If the key is already in fields
if key in json[INFLUX_CONF_FIELDS]:
key = f"{key}_"
# Prevent column data errors in influxDB.
# For each value we try to cast it as float
# But if we can not do it we store the value
# as string add "_str" postfix to the field key
try:
json[INFLUX_CONF_FIELDS][key] = float(value)
except (ValueError, TypeError):
new_key = f"{key}_str"
new_value = str(value)
json[INFLUX_CONF_FIELDS][new_key] = new_value
if RE_DIGIT_TAIL.match(new_value):
json[INFLUX_CONF_FIELDS][key] = float(
RE_DECIMAL.sub("", new_value)
)
# Infinity and NaN are not valid floats in InfluxDB
try:
if not math.isfinite(json[INFLUX_CONF_FIELDS][key]):
del json[INFLUX_CONF_FIELDS][key]
except (KeyError, TypeError):
pass
json[INFLUX_CONF_TAGS].update(tags)
return json
return event_to_json | [
"def",
"_generate_event_to_json",
"(",
"conf",
":",
"Dict",
")",
"->",
"Callable",
"[",
"[",
"Dict",
"]",
",",
"str",
"]",
":",
"entity_filter",
"=",
"convert_include_exclude_filter",
"(",
"conf",
")",
"tags",
"=",
"conf",
".",
"get",
"(",
"CONF_TAGS",
")"... | [
194,
0
] | [
313,
24
] | python | en | ['en', 'en', 'en'] | True |
get_influx_connection | (conf, test_write=False, test_read=False) | Create the correct influx connection for the API version. | Create the correct influx connection for the API version. | def get_influx_connection(conf, test_write=False, test_read=False):
"""Create the correct influx connection for the API version."""
kwargs = {
CONF_TIMEOUT: TIMEOUT,
}
precision = conf.get(CONF_PRECISION)
if conf[CONF_API_VERSION] == API_VERSION_2:
kwargs[CONF_URL] = conf[CONF_URL]
kwargs[CONF_TOKEN] = conf[CONF_TOKEN]
kwargs[INFLUX_CONF_ORG] = conf[CONF_ORG]
bucket = conf.get(CONF_BUCKET)
influx = InfluxDBClientV2(**kwargs)
query_api = influx.query_api()
initial_write_mode = SYNCHRONOUS if test_write else ASYNCHRONOUS
write_api = influx.write_api(write_options=initial_write_mode)
def write_v2(json):
"""Write data to V2 influx."""
data = {"bucket": bucket, "record": json}
if precision is not None:
data["write_precision"] = precision
try:
write_api.write(**data)
except (urllib3.exceptions.HTTPError, OSError) as exc:
raise ConnectionError(CONNECTION_ERROR % exc) from exc
except ApiException as exc:
if exc.status == CODE_INVALID_INPUTS:
raise ValueError(WRITE_ERROR % (json, exc)) from exc
raise ConnectionError(CLIENT_ERROR_V2 % exc) from exc
def query_v2(query, _=None):
"""Query V2 influx."""
try:
return query_api.query(query)
except (urllib3.exceptions.HTTPError, OSError) as exc:
raise ConnectionError(CONNECTION_ERROR % exc) from exc
except ApiException as exc:
if exc.status == CODE_INVALID_INPUTS:
raise ValueError(QUERY_ERROR % (query, exc)) from exc
raise ConnectionError(CLIENT_ERROR_V2 % exc) from exc
def close_v2():
"""Close V2 influx client."""
influx.close()
buckets = []
if test_write:
# Try to write b"" to influx. If we can connect and creds are valid
# Then invalid inputs is returned. Anything else is a broken config
try:
write_v2(b"")
except ValueError:
pass
write_api = influx.write_api(write_options=ASYNCHRONOUS)
if test_read:
tables = query_v2(TEST_QUERY_V2)
if tables and tables[0].records:
buckets = [bucket.values["name"] for bucket in tables[0].records]
else:
buckets = []
return InfluxClient(buckets, write_v2, query_v2, close_v2)
# Else it's a V1 client
kwargs[CONF_VERIFY_SSL] = conf[CONF_VERIFY_SSL]
if CONF_DB_NAME in conf:
kwargs[CONF_DB_NAME] = conf[CONF_DB_NAME]
if CONF_USERNAME in conf:
kwargs[CONF_USERNAME] = conf[CONF_USERNAME]
if CONF_PASSWORD in conf:
kwargs[CONF_PASSWORD] = conf[CONF_PASSWORD]
if CONF_HOST in conf:
kwargs[CONF_HOST] = conf[CONF_HOST]
if CONF_PATH in conf:
kwargs[CONF_PATH] = conf[CONF_PATH]
if CONF_PORT in conf:
kwargs[CONF_PORT] = conf[CONF_PORT]
if CONF_SSL in conf:
kwargs[CONF_SSL] = conf[CONF_SSL]
influx = InfluxDBClient(**kwargs)
def write_v1(json):
"""Write data to V1 influx."""
try:
influx.write_points(json, time_precision=precision)
except (
requests.exceptions.RequestException,
exceptions.InfluxDBServerError,
OSError,
) as exc:
raise ConnectionError(CONNECTION_ERROR % exc) from exc
except exceptions.InfluxDBClientError as exc:
if exc.code == CODE_INVALID_INPUTS:
raise ValueError(WRITE_ERROR % (json, exc)) from exc
raise ConnectionError(CLIENT_ERROR_V1 % exc) from exc
def query_v1(query, database=None):
"""Query V1 influx."""
try:
return list(influx.query(query, database=database).get_points())
except (
requests.exceptions.RequestException,
exceptions.InfluxDBServerError,
OSError,
) as exc:
raise ConnectionError(CONNECTION_ERROR % exc) from exc
except exceptions.InfluxDBClientError as exc:
if exc.code == CODE_INVALID_INPUTS:
raise ValueError(QUERY_ERROR % (query, exc)) from exc
raise ConnectionError(CLIENT_ERROR_V1 % exc) from exc
def close_v1():
"""Close the V1 Influx client."""
influx.close()
databases = []
if test_write:
write_v1([])
if test_read:
databases = [db["name"] for db in query_v1(TEST_QUERY_V1)]
return InfluxClient(databases, write_v1, query_v1, close_v1) | [
"def",
"get_influx_connection",
"(",
"conf",
",",
"test_write",
"=",
"False",
",",
"test_read",
"=",
"False",
")",
":",
"kwargs",
"=",
"{",
"CONF_TIMEOUT",
":",
"TIMEOUT",
",",
"}",
"precision",
"=",
"conf",
".",
"get",
"(",
"CONF_PRECISION",
")",
"if",
... | [
326,
0
] | [
460,
64
] | python | en | ['en', 'en', 'en'] | True |
setup | (hass, config) | Set up the InfluxDB component. | Set up the InfluxDB component. | def setup(hass, config):
"""Set up the InfluxDB component."""
conf = config[DOMAIN]
try:
influx = get_influx_connection(conf, test_write=True)
except ConnectionError as exc:
_LOGGER.error(RETRY_MESSAGE, exc)
event_helper.call_later(hass, RETRY_INTERVAL, lambda _: setup(hass, config))
return True
event_to_json = _generate_event_to_json(conf)
max_tries = conf.get(CONF_RETRY_COUNT)
instance = hass.data[DOMAIN] = InfluxThread(hass, influx, event_to_json, max_tries)
instance.start()
def shutdown(event):
"""Shut down the thread."""
instance.queue.put(None)
instance.join()
influx.close()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, shutdown)
return True | [
"def",
"setup",
"(",
"hass",
",",
"config",
")",
":",
"conf",
"=",
"config",
"[",
"DOMAIN",
"]",
"try",
":",
"influx",
"=",
"get_influx_connection",
"(",
"conf",
",",
"test_write",
"=",
"True",
")",
"except",
"ConnectionError",
"as",
"exc",
":",
"_LOGGER... | [
463,
0
] | [
486,
15
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.__init__ | (self, hass, influx, event_to_json, max_tries) | Initialize the listener. | Initialize the listener. | def __init__(self, hass, influx, event_to_json, max_tries):
"""Initialize the listener."""
threading.Thread.__init__(self, name=DOMAIN)
self.queue = queue.Queue()
self.influx = influx
self.event_to_json = event_to_json
self.max_tries = max_tries
self.write_errors = 0
self.shutdown = False
hass.bus.listen(EVENT_STATE_CHANGED, self._event_listener) | [
"def",
"__init__",
"(",
"self",
",",
"hass",
",",
"influx",
",",
"event_to_json",
",",
"max_tries",
")",
":",
"threading",
".",
"Thread",
".",
"__init__",
"(",
"self",
",",
"name",
"=",
"DOMAIN",
")",
"self",
".",
"queue",
"=",
"queue",
".",
"Queue",
... | [
492,
4
] | [
501,
66
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread._event_listener | (self, event) | Listen for new messages on the bus and queue them for Influx. | Listen for new messages on the bus and queue them for Influx. | def _event_listener(self, event):
"""Listen for new messages on the bus and queue them for Influx."""
item = (time.monotonic(), event)
self.queue.put(item) | [
"def",
"_event_listener",
"(",
"self",
",",
"event",
")",
":",
"item",
"=",
"(",
"time",
".",
"monotonic",
"(",
")",
",",
"event",
")",
"self",
".",
"queue",
".",
"put",
"(",
"item",
")"
] | [
504,
4
] | [
507,
28
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.batch_timeout | () | Return number of seconds to wait for more events. | Return number of seconds to wait for more events. | def batch_timeout():
"""Return number of seconds to wait for more events."""
return BATCH_TIMEOUT | [
"def",
"batch_timeout",
"(",
")",
":",
"return",
"BATCH_TIMEOUT"
] | [
510,
4
] | [
512,
28
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.get_events_json | (self) | Return a batch of events formatted for writing. | Return a batch of events formatted for writing. | def get_events_json(self):
"""Return a batch of events formatted for writing."""
queue_seconds = QUEUE_BACKLOG_SECONDS + self.max_tries * RETRY_DELAY
count = 0
json = []
dropped = 0
try:
while len(json) < BATCH_BUFFER_SIZE and not self.shutdown:
timeout = None if count == 0 else self.batch_timeout()
item = self.queue.get(timeout=timeout)
count += 1
if item is None:
self.shutdown = True
else:
timestamp, event = item
age = time.monotonic() - timestamp
if age < queue_seconds:
event_json = self.event_to_json(event)
if event_json:
json.append(event_json)
else:
dropped += 1
except queue.Empty:
pass
if dropped:
_LOGGER.warning(CATCHING_UP_MESSAGE, dropped)
return count, json | [
"def",
"get_events_json",
"(",
"self",
")",
":",
"queue_seconds",
"=",
"QUEUE_BACKLOG_SECONDS",
"+",
"self",
".",
"max_tries",
"*",
"RETRY_DELAY",
"count",
"=",
"0",
"json",
"=",
"[",
"]",
"dropped",
"=",
"0",
"try",
":",
"while",
"len",
"(",
"json",
")"... | [
514,
4
] | [
548,
26
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.write_to_influxdb | (self, json) | Write preprocessed events to influxdb, with retry. | Write preprocessed events to influxdb, with retry. | def write_to_influxdb(self, json):
"""Write preprocessed events to influxdb, with retry."""
for retry in range(self.max_tries + 1):
try:
self.influx.write(json)
if self.write_errors:
_LOGGER.error(RESUMED_MESSAGE, self.write_errors)
self.write_errors = 0
_LOGGER.debug(WROTE_MESSAGE, len(json))
break
except ValueError as err:
_LOGGER.error(err)
break
except ConnectionError as err:
if retry < self.max_tries:
time.sleep(RETRY_DELAY)
else:
if not self.write_errors:
_LOGGER.error(err)
self.write_errors += len(json) | [
"def",
"write_to_influxdb",
"(",
"self",
",",
"json",
")",
":",
"for",
"retry",
"in",
"range",
"(",
"self",
".",
"max_tries",
"+",
"1",
")",
":",
"try",
":",
"self",
".",
"influx",
".",
"write",
"(",
"json",
")",
"if",
"self",
".",
"write_errors",
... | [
550,
4
] | [
571,
50
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.run | (self) | Process incoming events. | Process incoming events. | def run(self):
"""Process incoming events."""
while not self.shutdown:
count, json = self.get_events_json()
if json:
self.write_to_influxdb(json)
for _ in range(count):
self.queue.task_done() | [
"def",
"run",
"(",
"self",
")",
":",
"while",
"not",
"self",
".",
"shutdown",
":",
"count",
",",
"json",
"=",
"self",
".",
"get_events_json",
"(",
")",
"if",
"json",
":",
"self",
".",
"write_to_influxdb",
"(",
"json",
")",
"for",
"_",
"in",
"range",
... | [
573,
4
] | [
580,
38
] | python | en | ['en', 'en', 'en'] | True |
InfluxThread.block_till_done | (self) | Block till all events processed. | Block till all events processed. | def block_till_done(self):
"""Block till all events processed."""
self.queue.join() | [
"def",
"block_till_done",
"(",
"self",
")",
":",
"self",
".",
"queue",
".",
"join",
"(",
")"
] | [
582,
4
] | [
584,
25
] | python | en | ['sv', 'en', 'en'] | True |
async_assert_state_equals | (
entity_id: str, state_obj: State, expected: Any, attribute: WithingsAttribute
) | Assert at given state matches what is expected. | Assert at given state matches what is expected. | def async_assert_state_equals(
entity_id: str, state_obj: State, expected: Any, attribute: WithingsAttribute
) -> None:
"""Assert at given state matches what is expected."""
assert state_obj, f"Expected entity {entity_id} to exist but it did not"
assert state_obj.state == str(expected), (
f"Expected {expected} but was {state_obj.state} "
f"for measure {attribute.measurement}, {entity_id}"
) | [
"def",
"async_assert_state_equals",
"(",
"entity_id",
":",
"str",
",",
"state_obj",
":",
"State",
",",
"expected",
":",
"Any",
",",
"attribute",
":",
"WithingsAttribute",
")",
"->",
"None",
":",
"assert",
"state_obj",
",",
"f\"Expected entity {entity_id} to exist bu... | [
290,
0
] | [
299,
5
] | python | en | ['en', 'en', 'en'] | True |
test_sensor_default_enabled_entities | (
hass: HomeAssistant, component_factory: ComponentFactory
) | Test entities enabled by default. | Test entities enabled by default. | async def test_sensor_default_enabled_entities(
hass: HomeAssistant, component_factory: ComponentFactory
) -> None:
"""Test entities enabled by default."""
entity_registry: EntityRegistry = (
await hass.helpers.entity_registry.async_get_registry()
)
await component_factory.configure_component(profile_configs=(PERSON0,))
# Assert entities should not exist yet.
for attribute in get_platform_attributes(SENSOR_DOMAIN):
assert not await async_get_entity_id(hass, attribute, PERSON0.user_id)
# person 0
await component_factory.setup_profile(PERSON0.user_id)
# Assert entities should exist.
for attribute in get_platform_attributes(SENSOR_DOMAIN):
entity_id = await async_get_entity_id(hass, attribute, PERSON0.user_id)
assert entity_id
assert entity_registry.async_is_registered(entity_id)
resp = await component_factory.call_webhook(PERSON0.user_id, NotifyAppli.SLEEP)
assert resp.message_code == 0
resp = await component_factory.call_webhook(PERSON0.user_id, NotifyAppli.WEIGHT)
assert resp.message_code == 0
for person, measurement, expected in EXPECTED_DATA:
attribute = WITHINGS_MEASUREMENTS_MAP[measurement]
entity_id = await async_get_entity_id(hass, attribute, person.user_id)
state_obj = hass.states.get(entity_id)
if attribute.enabled_by_default:
async_assert_state_equals(entity_id, state_obj, expected, attribute)
else:
assert state_obj is None
# Unload
await component_factory.unload(PERSON0) | [
"async",
"def",
"test_sensor_default_enabled_entities",
"(",
"hass",
":",
"HomeAssistant",
",",
"component_factory",
":",
"ComponentFactory",
")",
"->",
"None",
":",
"entity_registry",
":",
"EntityRegistry",
"=",
"(",
"await",
"hass",
".",
"helpers",
".",
"entity_re... | [
302,
0
] | [
342,
43
] | python | en | ['en', 'en', 'en'] | True |
test_all_entities | (
hass: HomeAssistant, component_factory: ComponentFactory
) | Test all entities. | Test all entities. | async def test_all_entities(
hass: HomeAssistant, component_factory: ComponentFactory
) -> None:
"""Test all entities."""
entity_registry: EntityRegistry = (
await hass.helpers.entity_registry.async_get_registry()
)
with patch(
"homeassistant.components.withings.sensor.BaseWithingsSensor.entity_registry_enabled_default"
) as enabled_by_default_mock:
enabled_by_default_mock.return_value = True
await component_factory.configure_component(profile_configs=(PERSON0,))
# Assert entities should not exist yet.
for attribute in get_platform_attributes(SENSOR_DOMAIN):
assert not await async_get_entity_id(hass, attribute, PERSON0.user_id)
# person 0
await component_factory.setup_profile(PERSON0.user_id)
# Assert entities should exist.
for attribute in get_platform_attributes(SENSOR_DOMAIN):
entity_id = await async_get_entity_id(hass, attribute, PERSON0.user_id)
assert entity_id
assert entity_registry.async_is_registered(entity_id)
resp = await component_factory.call_webhook(PERSON0.user_id, NotifyAppli.SLEEP)
assert resp.message_code == 0
resp = await component_factory.call_webhook(PERSON0.user_id, NotifyAppli.WEIGHT)
assert resp.message_code == 0
for person, measurement, expected in EXPECTED_DATA:
attribute = WITHINGS_MEASUREMENTS_MAP[measurement]
entity_id = await async_get_entity_id(hass, attribute, person.user_id)
state_obj = hass.states.get(entity_id)
async_assert_state_equals(entity_id, state_obj, expected, attribute)
# Unload
await component_factory.unload(PERSON0) | [
"async",
"def",
"test_all_entities",
"(",
"hass",
":",
"HomeAssistant",
",",
"component_factory",
":",
"ComponentFactory",
")",
"->",
"None",
":",
"entity_registry",
":",
"EntityRegistry",
"=",
"(",
"await",
"hass",
".",
"helpers",
".",
"entity_registry",
".",
"... | [
345,
0
] | [
387,
43
] | python | en | ['sv', 'en', 'en'] | True |
test_hls_stream | (hass, hass_client) |
Test hls stream.
Purposefully not mocking anything here to test full
integration with the stream component.
|
Test hls stream. | async def test_hls_stream(hass, hass_client):
"""
Test hls stream.
Purposefully not mocking anything here to test full
integration with the stream component.
"""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
stream.add_provider("hls")
# Request stream
url = request_stream(hass, source)
http_client = await hass_client()
# Fetch playlist
parsed_url = urlparse(url)
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Fetch init
playlist = await playlist_response.text()
playlist_url = "/".join(parsed_url.path.split("/")[:-1])
init_url = playlist_url + "/init.mp4"
init_response = await http_client.get(init_url)
assert init_response.status == 200
# Fetch segment
playlist = await playlist_response.text()
playlist_url = "/".join(parsed_url.path.split("/")[:-1])
segment_url = playlist_url + playlist.splitlines()[-1][1:]
segment_response = await http_client.get(segment_url)
assert segment_response.status == 200
# Stop stream, if it hasn't quit already
stream.stop()
# Ensure playlist not accessible after stream ends
fail_response = await http_client.get(parsed_url.path)
assert fail_response.status == HTTP_NOT_FOUND | [
"async",
"def",
"test_hls_stream",
"(",
"hass",
",",
"hass_client",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"\"stream\"",
",",
"{",
"\"stream\"",
":",
"{",
"}",
"}",
")",
"# Setup demo HLS track",
"source",
"=",
"generate_h264_video",
"(",
... | [
18,
0
] | [
61,
49
] | python | en | ['en', 'error', 'th'] | False |
test_stream_timeout | (hass, hass_client) | Test hls stream timeout. | Test hls stream timeout. | async def test_stream_timeout(hass, hass_client):
"""Test hls stream timeout."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
stream.add_provider("hls")
# Request stream
url = request_stream(hass, source)
http_client = await hass_client()
# Fetch playlist
parsed_url = urlparse(url)
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Wait a minute
future = dt_util.utcnow() + timedelta(minutes=1)
async_fire_time_changed(hass, future)
# Fetch again to reset timer
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Wait 5 minutes
future = dt_util.utcnow() + timedelta(minutes=5)
async_fire_time_changed(hass, future)
# Ensure playlist not accessible
fail_response = await http_client.get(parsed_url.path)
assert fail_response.status == HTTP_NOT_FOUND | [
"async",
"def",
"test_stream_timeout",
"(",
"hass",
",",
"hass_client",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"\"stream\"",
",",
"{",
"\"stream\"",
":",
"{",
"}",
"}",
")",
"# Setup demo HLS track",
"source",
"=",
"generate_h264_video",
"... | [
65,
0
] | [
98,
49
] | python | en | ['en', 'en', 'en'] | True |
test_stream_ended | (hass) | Test hls stream packets ended. | Test hls stream packets ended. | async def test_stream_ended(hass):
"""Test hls stream packets ended."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
track = stream.add_provider("hls")
# Request stream
request_stream(hass, source)
# Run it dead
while True:
segment = await track.recv()
if segment is None:
break
segments = segment.sequence
assert segments > 1
assert not track.get_segment()
# Stop stream, if it hasn't quit already
stream.stop() | [
"async",
"def",
"test_stream_ended",
"(",
"hass",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"\"stream\"",
",",
"{",
"\"stream\"",
":",
"{",
"}",
"}",
")",
"# Setup demo HLS track",
"source",
"=",
"generate_h264_video",
"(",
")",
"stream",
"... | [
102,
0
] | [
125,
17
] | python | en | ['en', 'en', 'en'] | True |
test_stream_keepalive | (hass) | Test hls stream retries the stream when keepalive=True. | Test hls stream retries the stream when keepalive=True. | async def test_stream_keepalive(hass):
"""Test hls stream retries the stream when keepalive=True."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = "test_stream_keepalive_source"
stream = preload_stream(hass, source)
track = stream.add_provider("hls")
track.num_segments = 2
cur_time = 0
def time_side_effect():
nonlocal cur_time
if cur_time >= 80:
stream.keepalive = False # Thread should exit and be joinable.
cur_time += 40
return cur_time
with patch("av.open") as av_open, patch(
"homeassistant.components.stream.worker.time"
) as mock_time, patch(
"homeassistant.components.stream.worker.STREAM_RESTART_INCREMENT", 0
):
av_open.side_effect = av.error.InvalidDataError(-2, "error")
mock_time.time.side_effect = time_side_effect
# Request stream
request_stream(hass, source, keepalive=True)
stream._thread.join()
stream._thread = None
assert av_open.call_count == 2
# Stop stream, if it hasn't quit already
stream.stop() | [
"async",
"def",
"test_stream_keepalive",
"(",
"hass",
")",
":",
"await",
"async_setup_component",
"(",
"hass",
",",
"\"stream\"",
",",
"{",
"\"stream\"",
":",
"{",
"}",
"}",
")",
"# Setup demo HLS track",
"source",
"=",
"\"test_stream_keepalive_source\"",
"stream",
... | [
128,
0
] | [
161,
17
] | python | en | ['en', 'de', 'en'] | True |
get_log_path | (experiment_id) | generate stdout and stderr log path | generate stdout and stderr log path | def get_log_path(experiment_id):
'''generate stdout and stderr log path'''
os.makedirs(os.path.join(NNI_HOME_DIR, experiment_id, 'log'), exist_ok=True)
stdout_full_path = os.path.join(NNI_HOME_DIR, experiment_id, 'log', 'nnictl_stdout.log')
stderr_full_path = os.path.join(NNI_HOME_DIR, experiment_id, 'log', 'nnictl_stderr.log')
return stdout_full_path, stderr_full_path | [
"def",
"get_log_path",
"(",
"experiment_id",
")",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"join",
"(",
"NNI_HOME_DIR",
",",
"experiment_id",
",",
"'log'",
")",
",",
"exist_ok",
"=",
"True",
")",
"stdout_full_path",
"=",
"os",
".",
"path"... | [
29,
0
] | [
34,
45
] | python | en | ['en', 'en', 'en'] | True |
print_log_content | (config_file_name) | print log information | print log information | def print_log_content(config_file_name):
'''print log information'''
stdout_full_path, stderr_full_path = get_log_path(config_file_name)
print_normal(' Stdout:')
print(check_output_command(stdout_full_path))
print('\n\n')
print_normal(' Stderr:')
print(check_output_command(stderr_full_path)) | [
"def",
"print_log_content",
"(",
"config_file_name",
")",
":",
"stdout_full_path",
",",
"stderr_full_path",
"=",
"get_log_path",
"(",
"config_file_name",
")",
"print_normal",
"(",
"' Stdout:'",
")",
"print",
"(",
"check_output_command",
"(",
"stdout_full_path",
")",
"... | [
36,
0
] | [
43,
49
] | python | en | ['fr', 'jv', 'en'] | False |
start_rest_server | (port, platform, mode, experiment_id, foreground=False, log_dir=None, log_level=None, url_prefix=None) | Run nni manager process | Run nni manager process | def start_rest_server(port, platform, mode, experiment_id, foreground=False, log_dir=None, log_level=None, url_prefix=None):
'''Run nni manager process'''
if detect_port(port):
print_error('Port %s is used by another process, please reset the port!\n' \
'You could use \'nnictl create --help\' to get help information' % port)
exit(1)
if (platform not in ['local', 'aml']) and detect_port(int(port) + 1):
print_error('%s mode need an additional adjacent port %d, and the port %d is used by another process!\n' \
'You could set another port to start experiment!\n' \
'You could use \'nnictl create --help\' to get help information' % (platform, (int(port) + 1), (int(port) + 1)))
exit(1)
print_normal('Starting restful server...')
entry_dir = nni_node.__path__[0]
if (not entry_dir) or (not os.path.exists(entry_dir)):
print_error('Fail to find nni under python library')
exit(1)
entry_file = os.path.join(entry_dir, 'main.js')
if sys.platform == 'win32':
node_command = os.path.join(entry_dir, 'node.exe')
else:
node_command = os.path.join(entry_dir, 'node')
cmds = [node_command, '--max-old-space-size=4096', entry_file, '--port', str(port), '--mode', platform, \
'--experiment_id', experiment_id]
if mode == 'view':
cmds += ['--start_mode', 'resume']
cmds += ['--readonly', 'true']
else:
cmds += ['--start_mode', mode]
if log_dir is not None:
cmds += ['--log_dir', log_dir]
if log_level is not None:
cmds += ['--log_level', log_level]
if foreground:
cmds += ['--foreground', 'true']
if url_prefix:
_validate_prefix_path(url_prefix)
set_prefix_url(url_prefix)
cmds += ['--url_prefix', url_prefix]
stdout_full_path, stderr_full_path = get_log_path(experiment_id)
with open(stdout_full_path, 'a+') as stdout_file, open(stderr_full_path, 'a+') as stderr_file:
start_time = time.time()
time_now = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(start_time))
#add time information in the header of log files
log_header = LOG_HEADER % str(time_now)
stdout_file.write(log_header)
stderr_file.write(log_header)
if sys.platform == 'win32':
from subprocess import CREATE_NEW_PROCESS_GROUP
if foreground:
process = Popen(cmds, cwd=entry_dir, stdout=PIPE, stderr=STDOUT, creationflags=CREATE_NEW_PROCESS_GROUP)
else:
process = Popen(cmds, cwd=entry_dir, stdout=stdout_file, stderr=stderr_file, creationflags=CREATE_NEW_PROCESS_GROUP)
else:
if foreground:
process = Popen(cmds, cwd=entry_dir, stdout=PIPE, stderr=PIPE)
else:
process = Popen(cmds, cwd=entry_dir, stdout=stdout_file, stderr=stderr_file)
return process, int(start_time * 1000) | [
"def",
"start_rest_server",
"(",
"port",
",",
"platform",
",",
"mode",
",",
"experiment_id",
",",
"foreground",
"=",
"False",
",",
"log_dir",
"=",
"None",
",",
"log_level",
"=",
"None",
",",
"url_prefix",
"=",
"None",
")",
":",
"if",
"detect_port",
"(",
... | [
45,
0
] | [
107,
42
] | python | da | ['da', 'ha', 'en'] | False |
set_trial_config | (experiment_config, port, config_file_name) | set trial configuration | set trial configuration | def set_trial_config(experiment_config, port, config_file_name):
'''set trial configuration'''
request_data = dict()
request_data['trial_config'] = experiment_config['trial']
response = rest_put(cluster_metadata_url(port), json.dumps(request_data), REST_TIME_OUT)
if check_response(response):
return True
else:
print('Error message is {}'.format(response.text))
_, stderr_full_path = get_log_path(config_file_name)
if response:
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(response.text), indent=4, sort_keys=True, separators=(',', ':')))
return False | [
"def",
"set_trial_config",
"(",
"experiment_config",
",",
"port",
",",
"config_file_name",
")",
":",
"request_data",
"=",
"dict",
"(",
")",
"request_data",
"[",
"'trial_config'",
"]",
"=",
"experiment_config",
"[",
"'trial'",
"]",
"response",
"=",
"rest_put",
"(... | [
109,
0
] | [
122,
20
] | python | en | ['en', 'fr', 'en'] | True |
set_adl_config | (experiment_config, port, config_file_name) | set adl configuration | set adl configuration | def set_adl_config(experiment_config, port, config_file_name):
'''set adl configuration'''
adl_config_data = dict()
# hack for supporting v2 config, need refactor
adl_config_data['adl_config'] = {}
response = rest_put(cluster_metadata_url(port), json.dumps(adl_config_data), REST_TIME_OUT)
err_message = None
if not response or not response.status_code == 200:
if response is not None:
err_message = response.text
_, stderr_full_path = get_log_path(config_file_name)
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(err_message), indent=4, sort_keys=True, separators=(',', ':')))
return False, err_message
set_V1_common_config(experiment_config, port, config_file_name)
result, message = setNNIManagerIp(experiment_config, port, config_file_name)
if not result:
return result, message
#set trial_config
return set_trial_config(experiment_config, port, config_file_name), None | [
"def",
"set_adl_config",
"(",
"experiment_config",
",",
"port",
",",
"config_file_name",
")",
":",
"adl_config_data",
"=",
"dict",
"(",
")",
"# hack for supporting v2 config, need refactor",
"adl_config_data",
"[",
"'adl_config'",
"]",
"=",
"{",
"}",
"response",
"=",
... | [
124,
0
] | [
143,
76
] | python | en | ['en', 'fr', 'en'] | True |
setNNIManagerIp | (experiment_config, port, config_file_name) | set nniManagerIp | set nniManagerIp | def setNNIManagerIp(experiment_config, port, config_file_name):
'''set nniManagerIp'''
if experiment_config.get('nniManagerIp') is None:
return True, None
ip_config_dict = dict()
ip_config_dict['nni_manager_ip'] = {'nniManagerIp': experiment_config['nniManagerIp']}
response = rest_put(cluster_metadata_url(port), json.dumps(ip_config_dict), REST_TIME_OUT)
err_message = None
if not response or not response.status_code == 200:
if response is not None:
err_message = response.text
_, stderr_full_path = get_log_path(config_file_name)
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(err_message), indent=4, sort_keys=True, separators=(',', ':')))
return False, err_message
return True, None | [
"def",
"setNNIManagerIp",
"(",
"experiment_config",
",",
"port",
",",
"config_file_name",
")",
":",
"if",
"experiment_config",
".",
"get",
"(",
"'nniManagerIp'",
")",
"is",
"None",
":",
"return",
"True",
",",
"None",
"ip_config_dict",
"=",
"dict",
"(",
")",
... | [
172,
0
] | [
187,
21
] | python | da | ['en', 'da', 'sw'] | False |
set_kubeflow_config | (experiment_config, port, config_file_name) | set kubeflow configuration | set kubeflow configuration | def set_kubeflow_config(experiment_config, port, config_file_name):
'''set kubeflow configuration'''
kubeflow_config_data = dict()
kubeflow_config_data['kubeflow_config'] = experiment_config['kubeflowConfig']
response = rest_put(cluster_metadata_url(port), json.dumps(kubeflow_config_data), REST_TIME_OUT)
err_message = None
if not response or not response.status_code == 200:
if response is not None:
err_message = response.text
_, stderr_full_path = get_log_path(config_file_name)
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(err_message), indent=4, sort_keys=True, separators=(',', ':')))
return False, err_message
set_V1_common_config(experiment_config, port, config_file_name)
result, message = setNNIManagerIp(experiment_config, port, config_file_name)
if not result:
return result, message
#set trial_config
return set_trial_config(experiment_config, port, config_file_name), err_message | [
"def",
"set_kubeflow_config",
"(",
"experiment_config",
",",
"port",
",",
"config_file_name",
")",
":",
"kubeflow_config_data",
"=",
"dict",
"(",
")",
"kubeflow_config_data",
"[",
"'kubeflow_config'",
"]",
"=",
"experiment_config",
"[",
"'kubeflowConfig'",
"]",
"respo... | [
189,
0
] | [
207,
83
] | python | en | ['en', 'xh', 'ur'] | False |
set_frameworkcontroller_config | (experiment_config, port, config_file_name) | set kubeflow configuration | set kubeflow configuration | def set_frameworkcontroller_config(experiment_config, port, config_file_name):
'''set kubeflow configuration'''
frameworkcontroller_config_data = dict()
frameworkcontroller_config_data['frameworkcontroller_config'] = experiment_config['frameworkcontrollerConfig']
response = rest_put(cluster_metadata_url(port), json.dumps(frameworkcontroller_config_data), REST_TIME_OUT)
err_message = None
if not response or not response.status_code == 200:
if response is not None:
err_message = response.text
_, stderr_full_path = get_log_path(config_file_name)
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(err_message), indent=4, sort_keys=True, separators=(',', ':')))
return False, err_message
set_V1_common_config(experiment_config, port, config_file_name)
result, message = setNNIManagerIp(experiment_config, port, config_file_name)
if not result:
return result, message
#set trial_config
return set_trial_config(experiment_config, port, config_file_name), err_message | [
"def",
"set_frameworkcontroller_config",
"(",
"experiment_config",
",",
"port",
",",
"config_file_name",
")",
":",
"frameworkcontroller_config_data",
"=",
"dict",
"(",
")",
"frameworkcontroller_config_data",
"[",
"'frameworkcontroller_config'",
"]",
"=",
"experiment_config",
... | [
209,
0
] | [
227,
83
] | python | en | ['en', 'xh', 'ur'] | False |
set_experiment_v1 | (experiment_config, mode, port, config_file_name) | Call startExperiment (rest POST /experiment) with yaml file content | Call startExperiment (rest POST /experiment) with yaml file content | def set_experiment_v1(experiment_config, mode, port, config_file_name):
'''Call startExperiment (rest POST /experiment) with yaml file content'''
request_data = dict()
request_data['authorName'] = experiment_config['authorName']
request_data['experimentName'] = experiment_config['experimentName']
request_data['trialConcurrency'] = experiment_config['trialConcurrency']
request_data['maxExecDuration'] = experiment_config['maxExecDuration']
request_data['maxExperimentDuration'] = str(experiment_config['maxExecDuration']) + 's'
request_data['maxTrialNum'] = experiment_config['maxTrialNum']
request_data['maxTrialNumber'] = experiment_config['maxTrialNum']
request_data['searchSpace'] = experiment_config.get('searchSpace')
request_data['trainingServicePlatform'] = experiment_config.get('trainingServicePlatform')
# hack for hotfix, fix config.trainingService undefined error, need refactor
request_data['trainingService'] = {'platform': experiment_config.get('trainingServicePlatform')}
if experiment_config.get('description'):
request_data['description'] = experiment_config['description']
if experiment_config.get('multiPhase'):
request_data['multiPhase'] = experiment_config.get('multiPhase')
if experiment_config.get('multiThread'):
request_data['multiThread'] = experiment_config.get('multiThread')
if experiment_config.get('nniManagerIp'):
request_data['nniManagerIp'] = experiment_config.get('nniManagerIp')
if experiment_config.get('advisor'):
request_data['advisor'] = experiment_config['advisor']
if request_data['advisor'].get('gpuNum'):
print_error('gpuNum is deprecated, please use gpuIndices instead.')
if request_data['advisor'].get('gpuIndices') and isinstance(request_data['advisor'].get('gpuIndices'), int):
request_data['advisor']['gpuIndices'] = str(request_data['advisor'].get('gpuIndices'))
else:
request_data['tuner'] = experiment_config['tuner']
if request_data['tuner'].get('gpuNum'):
print_error('gpuNum is deprecated, please use gpuIndices instead.')
if request_data['tuner'].get('gpuIndices') and isinstance(request_data['tuner'].get('gpuIndices'), int):
request_data['tuner']['gpuIndices'] = str(request_data['tuner'].get('gpuIndices'))
if 'assessor' in experiment_config:
request_data['assessor'] = experiment_config['assessor']
if request_data['assessor'].get('gpuNum'):
print_error('gpuNum is deprecated, please remove it from your config file.')
#debug mode should disable version check
if experiment_config.get('debug') is not None:
request_data['versionCheck'] = not experiment_config.get('debug')
#validate version check
if experiment_config.get('versionCheck') is not None:
request_data['versionCheck'] = experiment_config.get('versionCheck')
if experiment_config.get('logCollection'):
request_data['logCollection'] = experiment_config.get('logCollection')
request_data['clusterMetaData'] = []
if experiment_config['trainingServicePlatform'] == 'kubeflow':
request_data['clusterMetaData'].append(
{'key': 'kubeflow_config', 'value': experiment_config['kubeflowConfig']})
request_data['clusterMetaData'].append(
{'key': 'trial_config', 'value': experiment_config['trial']})
elif experiment_config['trainingServicePlatform'] == 'frameworkcontroller':
request_data['clusterMetaData'].append(
{'key': 'frameworkcontroller_config', 'value': experiment_config['frameworkcontrollerConfig']})
request_data['clusterMetaData'].append(
{'key': 'trial_config', 'value': experiment_config['trial']})
elif experiment_config['trainingServicePlatform'] == 'adl':
request_data['clusterMetaData'].append(
{'key': 'trial_config', 'value': experiment_config['trial']})
response = rest_post(experiment_url(port), json.dumps(request_data), REST_TIME_OUT, show_error=True)
if check_response(response):
return response
else:
_, stderr_full_path = get_log_path(config_file_name)
if response is not None:
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(response.text), indent=4, sort_keys=True, separators=(',', ':')))
print_error('Setting experiment error, error message is {}'.format(response.text))
return None | [
"def",
"set_experiment_v1",
"(",
"experiment_config",
",",
"mode",
",",
"port",
",",
"config_file_name",
")",
":",
"request_data",
"=",
"dict",
"(",
")",
"request_data",
"[",
"'authorName'",
"]",
"=",
"experiment_config",
"[",
"'authorName'",
"]",
"request_data",
... | [
243,
0
] | [
312,
19
] | python | en | ['en', 'en', 'en'] | True |
set_experiment_v2 | (experiment_config, mode, port, config_file_name) | Call startExperiment (rest POST /experiment) with yaml file content | Call startExperiment (rest POST /experiment) with yaml file content | def set_experiment_v2(experiment_config, mode, port, config_file_name):
'''Call startExperiment (rest POST /experiment) with yaml file content'''
response = rest_post(experiment_url(port), json.dumps(experiment_config), REST_TIME_OUT, show_error=True)
if check_response(response):
return response
else:
_, stderr_full_path = get_log_path(config_file_name)
if response is not None:
with open(stderr_full_path, 'a+') as fout:
fout.write(json.dumps(json.loads(response.text), indent=4, sort_keys=True, separators=(',', ':')))
print_error('Setting experiment error, error message is {}'.format(response.text))
return None | [
"def",
"set_experiment_v2",
"(",
"experiment_config",
",",
"mode",
",",
"port",
",",
"config_file_name",
")",
":",
"response",
"=",
"rest_post",
"(",
"experiment_url",
"(",
"port",
")",
",",
"json",
".",
"dumps",
"(",
"experiment_config",
")",
",",
"REST_TIME_... | [
314,
0
] | [
325,
19
] | python | en | ['en', 'en', 'en'] | True |
set_platform_config | (platform, experiment_config, port, config_file_name, rest_process) | call set_cluster_metadata for specific platform | call set_cluster_metadata for specific platform | def set_platform_config(platform, experiment_config, port, config_file_name, rest_process):
'''call set_cluster_metadata for specific platform'''
print_normal('Setting {0} config...'.format(platform))
config_result, err_msg = None, None
if platform == 'adl':
config_result, err_msg = set_adl_config(experiment_config, port, config_file_name)
elif platform == 'kubeflow':
config_result, err_msg = set_kubeflow_config(experiment_config, port, config_file_name)
elif platform == 'frameworkcontroller':
config_result, err_msg = set_frameworkcontroller_config(experiment_config, port, config_file_name)
else:
raise Exception(ERROR_INFO % 'Unsupported platform!')
exit(1)
if config_result:
config_result, err_msg = set_shared_storage(experiment_config, port, config_file_name)
if config_result:
print_normal('Successfully set {0} config!'.format(platform))
else:
print_error('Failed! Error is: {}'.format(err_msg))
try:
kill_command(rest_process.pid)
except Exception:
raise Exception(ERROR_INFO % 'Rest server stopped!')
exit(1) | [
"def",
"set_platform_config",
"(",
"platform",
",",
"experiment_config",
",",
"port",
",",
"config_file_name",
",",
"rest_process",
")",
":",
"print_normal",
"(",
"'Setting {0} config...'",
".",
"format",
"(",
"platform",
")",
")",
"config_result",
",",
"err_msg",
... | [
327,
0
] | [
350,
15
] | python | en | ['en', 'en', 'en'] | True |
launch_experiment | (args, experiment_config, mode, experiment_id, config_version) | follow steps to start rest server and start experiment | follow steps to start rest server and start experiment | def launch_experiment(args, experiment_config, mode, experiment_id, config_version):
'''follow steps to start rest server and start experiment'''
# check packages for tuner
package_name, module_name = None, None
if experiment_config.get('tuner') and experiment_config['tuner'].get('builtinTunerName'):
package_name = experiment_config['tuner']['builtinTunerName']
module_name, _ = get_builtin_module_class_name('tuners', package_name)
elif experiment_config.get('advisor') and experiment_config['advisor'].get('builtinAdvisorName'):
package_name = experiment_config['advisor']['builtinAdvisorName']
module_name, _ = get_builtin_module_class_name('advisors', package_name)
if package_name and module_name:
try:
stdout_full_path, stderr_full_path = get_log_path(experiment_id)
with open(stdout_full_path, 'a+') as stdout_file, open(stderr_full_path, 'a+') as stderr_file:
check_call([sys.executable, '-c', 'import %s'%(module_name)], stdout=stdout_file, stderr=stderr_file)
except CalledProcessError:
print_error('some errors happen when import package %s.' %(package_name))
print_log_content(experiment_id)
if package_name in ['SMAC', 'BOHB', 'PPOTuner']:
print_error(f'The dependencies for {package_name} can be installed through pip install nni[{package_name}]')
raise
if config_version == 1:
log_dir = experiment_config['logDir'] if experiment_config.get('logDir') else NNI_HOME_DIR
else:
log_dir = experiment_config['experimentWorkingDirectory'] if experiment_config.get('experimentWorkingDirectory') else NNI_HOME_DIR
log_level = experiment_config['logLevel'] if experiment_config.get('logLevel') else 'info'
#view experiment mode do not need debug function, when view an experiment, there will be no new logs created
foreground = False
if mode != 'view':
foreground = args.foreground
if log_level not in ['trace', 'debug'] and (args.debug or experiment_config.get('debug') is True):
log_level = 'debug'
# start rest server
if config_version == 1:
platform = experiment_config['trainingServicePlatform']
elif isinstance(experiment_config['trainingService'], list):
platform = 'hybrid'
else:
platform = experiment_config['trainingService']['platform']
rest_process, start_time = start_rest_server(args.port, platform, \
mode, experiment_id, foreground, log_dir, log_level, args.url_prefix)
# save experiment information
Experiments().add_experiment(experiment_id, args.port, start_time,
platform,
experiment_config.get('experimentName', 'N/A')
, pid=rest_process.pid, logDir=log_dir, prefixUrl=args.url_prefix)
# Deal with annotation
if experiment_config.get('useAnnotation'):
path = os.path.join(tempfile.gettempdir(), get_user(), 'nni', 'annotation')
if not os.path.isdir(path):
os.makedirs(path)
path = tempfile.mkdtemp(dir=path)
nas_mode = experiment_config['trial'].get('nasMode', 'classic_mode')
code_dir = expand_annotations(experiment_config['trial']['codeDir'], path, nas_mode=nas_mode)
experiment_config['trial']['codeDir'] = code_dir
search_space = generate_search_space(code_dir)
experiment_config['searchSpace'] = search_space
assert search_space, ERROR_INFO % 'Generated search space is empty'
elif config_version == 1:
if experiment_config.get('searchSpacePath'):
search_space = get_json_content(experiment_config.get('searchSpacePath'))
experiment_config['searchSpace'] = search_space
else:
experiment_config['searchSpace'] = ''
# check rest server
running, _ = check_rest_server(args.port)
if running:
print_normal('Successfully started Restful server!')
else:
print_error('Restful server start failed!')
print_log_content(experiment_id)
try:
kill_command(rest_process.pid)
except Exception:
raise Exception(ERROR_INFO % 'Rest server stopped!')
exit(1)
if config_version == 1 and mode != 'view':
# set platform configuration
set_platform_config(experiment_config['trainingServicePlatform'], experiment_config, args.port,\
experiment_id, rest_process)
# start a new experiment
print_normal('Starting experiment...')
# set debug configuration
if mode != 'view' and experiment_config.get('debug') is None:
experiment_config['debug'] = args.debug
if config_version == 1:
response = set_experiment_v1(experiment_config, mode, args.port, experiment_id)
else:
response = set_experiment_v2(experiment_config, mode, args.port, experiment_id)
if response:
if experiment_id is None:
experiment_id = json.loads(response.text).get('experiment_id')
else:
print_error('Start experiment failed!')
print_log_content(experiment_id)
try:
kill_command(rest_process.pid)
except Exception:
raise Exception(ERROR_INFO % 'Restful server stopped!')
exit(1)
url_prefix_format = '' if args.url_prefix is None else '/{0}'.format(args.url_prefix)
if experiment_config.get('nniManagerIp'):
web_ui_url_list = ['http://{0}:{1}{2}'.format(experiment_config['nniManagerIp'], str(args.port), url_prefix_format)]
else:
web_ui_url_list = get_local_urls(args.port, url_prefix_format)
Experiments().update_experiment(experiment_id, 'webuiUrl', web_ui_url_list)
print_normal(EXPERIMENT_SUCCESS_INFO % (experiment_id, ' '.join(web_ui_url_list)))
if mode != 'view' and args.foreground:
try:
while True:
log_content = rest_process.stdout.readline().strip().decode('utf-8')
print(log_content)
except KeyboardInterrupt:
kill_command(rest_process.pid)
print_normal('Stopping experiment...') | [
"def",
"launch_experiment",
"(",
"args",
",",
"experiment_config",
",",
"mode",
",",
"experiment_id",
",",
"config_version",
")",
":",
"# check packages for tuner",
"package_name",
",",
"module_name",
"=",
"None",
",",
"None",
"if",
"experiment_config",
".",
"get",
... | [
352,
0
] | [
470,
50
] | python | en | ['en', 'en', 'en'] | True |
create_experiment | (args) | start a new experiment | start a new experiment | def create_experiment(args):
'''start a new experiment'''
experiment_id = ''.join(random.sample(string.ascii_letters + string.digits, 8))
config_path = os.path.abspath(args.config)
if not os.path.exists(config_path):
print_error('Please set correct config path!')
exit(1)
config_yml = get_yml_content(config_path)
if 'trainingServicePlatform' in config_yml:
_validate_v1(config_yml, config_path)
platform = config_yml['trainingServicePlatform']
if platform in k8s_training_services:
schema = 1
config_v1 = config_yml
else:
schema = 2
config_v2 = convert.to_v2(config_yml).json()
else:
config_v2 = _validate_v2(config_yml, config_path)
schema = 2
try:
if schema == 1:
launch_experiment(args, config_v1, 'new', experiment_id, 1)
else:
launch_experiment(args, config_v2, 'new', experiment_id, 2)
except Exception as exception:
restServerPid = Experiments().get_all_experiments().get(experiment_id, {}).get('pid')
if restServerPid:
kill_command(restServerPid)
print_error(exception)
exit(1) | [
"def",
"create_experiment",
"(",
"args",
")",
":",
"experiment_id",
"=",
"''",
".",
"join",
"(",
"random",
".",
"sample",
"(",
"string",
".",
"ascii_letters",
"+",
"string",
".",
"digits",
",",
"8",
")",
")",
"config_path",
"=",
"os",
".",
"path",
".",... | [
493,
0
] | [
525,
15
] | python | en | ['it', 'lb', 'en'] | False |
manage_stopped_experiment | (args, mode) | view a stopped experiment | view a stopped experiment | def manage_stopped_experiment(args, mode):
'''view a stopped experiment'''
update_experiment()
experiments_config = Experiments()
experiments_dict = experiments_config.get_all_experiments()
experiment_id = None
#find the latest stopped experiment
if not args.id:
print_error('Please set experiment id! \nYou could use \'nnictl {0} id\' to {0} a stopped experiment!\n' \
'You could use \'nnictl experiment list --all\' to show all experiments!'.format(mode))
exit(1)
else:
if experiments_dict.get(args.id) is None:
print_error('Id %s not exist!' % args.id)
exit(1)
if experiments_dict[args.id]['status'] != 'STOPPED':
print_error('Only stopped experiments can be {0}ed!'.format(mode))
exit(1)
experiment_id = args.id
print_normal('{0} experiment {1}...'.format(mode, experiment_id))
experiment_config = Config(experiment_id, experiments_dict[args.id]['logDir']).get_config()
experiments_config.update_experiment(args.id, 'port', args.port)
args.url_prefix = experiments_dict[args.id]['prefixUrl']
assert 'trainingService' in experiment_config or 'trainingServicePlatform' in experiment_config
try:
if 'trainingServicePlatform' in experiment_config:
experiment_config['logDir'] = experiments_dict[args.id]['logDir']
launch_experiment(args, experiment_config, mode, experiment_id, 1)
else:
experiment_config['experimentWorkingDirectory'] = experiments_dict[args.id]['logDir']
launch_experiment(args, experiment_config, mode, experiment_id, 2)
except Exception as exception:
restServerPid = Experiments().get_all_experiments().get(experiment_id, {}).get('pid')
if restServerPid:
kill_command(restServerPid)
print_error(exception)
exit(1) | [
"def",
"manage_stopped_experiment",
"(",
"args",
",",
"mode",
")",
":",
"update_experiment",
"(",
")",
"experiments_config",
"=",
"Experiments",
"(",
")",
"experiments_dict",
"=",
"experiments_config",
".",
"get_all_experiments",
"(",
")",
"experiment_id",
"=",
"Non... | [
527,
0
] | [
563,
15
] | python | en | ['it', 'en', 'en'] | True |
view_experiment | (args) | view a stopped experiment | view a stopped experiment | def view_experiment(args):
'''view a stopped experiment'''
manage_stopped_experiment(args, 'view') | [
"def",
"view_experiment",
"(",
"args",
")",
":",
"manage_stopped_experiment",
"(",
"args",
",",
"'view'",
")"
] | [
565,
0
] | [
567,
43
] | python | en | ['it', 'en', 'en'] | True |
resume_experiment | (args) | resume an experiment | resume an experiment | def resume_experiment(args):
'''resume an experiment'''
manage_stopped_experiment(args, 'resume') | [
"def",
"resume_experiment",
"(",
"args",
")",
":",
"manage_stopped_experiment",
"(",
"args",
",",
"'resume'",
")"
] | [
569,
0
] | [
571,
45
] | python | en | ['en', 'en', 'en'] | True |
async_setup_entry | (
hass: HomeAssistantType, config_entry: ConfigEntry, async_add_entities
) | Set up the Minecraft Server sensor platform. | Set up the Minecraft Server sensor platform. | async def async_setup_entry(
hass: HomeAssistantType, config_entry: ConfigEntry, async_add_entities
) -> None:
"""Set up the Minecraft Server sensor platform."""
server = hass.data[DOMAIN][config_entry.unique_id]
# Create entities list.
entities = [
MinecraftServerVersionSensor(server),
MinecraftServerProtocolVersionSensor(server),
MinecraftServerLatencyTimeSensor(server),
MinecraftServerPlayersOnlineSensor(server),
MinecraftServerPlayersMaxSensor(server),
]
# Add sensor entities.
async_add_entities(entities, True) | [
"async",
"def",
"async_setup_entry",
"(",
"hass",
":",
"HomeAssistantType",
",",
"config_entry",
":",
"ConfigEntry",
",",
"async_add_entities",
")",
"->",
"None",
":",
"server",
"=",
"hass",
".",
"data",
"[",
"DOMAIN",
"]",
"[",
"config_entry",
".",
"unique_id... | [
28,
0
] | [
44,
38
] | python | en | ['en', 'lv', 'en'] | True |
MinecraftServerSensorEntity.__init__ | (
self,
server: MinecraftServer,
type_name: str,
icon: str = None,
unit: str = None,
device_class: str = None,
) | Initialize sensor base entity. | Initialize sensor base entity. | def __init__(
self,
server: MinecraftServer,
type_name: str,
icon: str = None,
unit: str = None,
device_class: str = None,
) -> None:
"""Initialize sensor base entity."""
super().__init__(server, type_name, icon, device_class)
self._state = None
self._unit = unit | [
"def",
"__init__",
"(",
"self",
",",
"server",
":",
"MinecraftServer",
",",
"type_name",
":",
"str",
",",
"icon",
":",
"str",
"=",
"None",
",",
"unit",
":",
"str",
"=",
"None",
",",
"device_class",
":",
"str",
"=",
"None",
",",
")",
"->",
"None",
"... | [
50,
4
] | [
61,
25
] | python | es | ['es', 'zu', 'it'] | False |
MinecraftServerSensorEntity.available | (self) | Return sensor availability. | Return sensor availability. | def available(self) -> bool:
"""Return sensor availability."""
return self._server.online | [
"def",
"available",
"(",
"self",
")",
"->",
"bool",
":",
"return",
"self",
".",
"_server",
".",
"online"
] | [
64,
4
] | [
66,
34
] | python | en | ['fr', 'ga', 'en'] | False |
MinecraftServerSensorEntity.state | (self) | Return sensor state. | Return sensor state. | def state(self) -> Any:
"""Return sensor state."""
return self._state | [
"def",
"state",
"(",
"self",
")",
"->",
"Any",
":",
"return",
"self",
".",
"_state"
] | [
69,
4
] | [
71,
26
] | python | en | ['en', 'bs', 'en'] | True |
MinecraftServerSensorEntity.unit_of_measurement | (self) | Return sensor measurement unit. | Return sensor measurement unit. | def unit_of_measurement(self) -> str:
"""Return sensor measurement unit."""
return self._unit | [
"def",
"unit_of_measurement",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"_unit"
] | [
74,
4
] | [
76,
25
] | python | en | ['en', 'ca', 'en'] | True |
MinecraftServerVersionSensor.__init__ | (self, server: MinecraftServer) | Initialize version sensor. | Initialize version sensor. | def __init__(self, server: MinecraftServer) -> None:
"""Initialize version sensor."""
super().__init__(
server=server, type_name=NAME_VERSION, icon=ICON_VERSION, unit=UNIT_VERSION
) | [
"def",
"__init__",
"(",
"self",
",",
"server",
":",
"MinecraftServer",
")",
"->",
"None",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"server",
"=",
"server",
",",
"type_name",
"=",
"NAME_VERSION",
",",
"icon",
"=",
"ICON_VERSION",
",",
"unit",
"=",
... | [
82,
4
] | [
86,
9
] | python | en | ['nl', 'ro', 'en'] | False |
MinecraftServerVersionSensor.async_update | (self) | Update version. | Update version. | async def async_update(self) -> None:
"""Update version."""
self._state = self._server.version | [
"async",
"def",
"async_update",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_state",
"=",
"self",
".",
"_server",
".",
"version"
] | [
88,
4
] | [
90,
42
] | python | de | ['nl', 'de', 'en'] | False |
MinecraftServerProtocolVersionSensor.__init__ | (self, server: MinecraftServer) | Initialize protocol version sensor. | Initialize protocol version sensor. | def __init__(self, server: MinecraftServer) -> None:
"""Initialize protocol version sensor."""
super().__init__(
server=server,
type_name=NAME_PROTOCOL_VERSION,
icon=ICON_PROTOCOL_VERSION,
unit=UNIT_PROTOCOL_VERSION,
) | [
"def",
"__init__",
"(",
"self",
",",
"server",
":",
"MinecraftServer",
")",
"->",
"None",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"server",
"=",
"server",
",",
"type_name",
"=",
"NAME_PROTOCOL_VERSION",
",",
"icon",
"=",
"ICON_PROTOCOL_VERSION",
",",
... | [
96,
4
] | [
103,
9
] | python | en | ['en', 'ro', 'en'] | True |
MinecraftServerProtocolVersionSensor.async_update | (self) | Update protocol version. | Update protocol version. | async def async_update(self) -> None:
"""Update protocol version."""
self._state = self._server.protocol_version | [
"async",
"def",
"async_update",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_state",
"=",
"self",
".",
"_server",
".",
"protocol_version"
] | [
105,
4
] | [
107,
51
] | python | en | ['en', 'en', 'en'] | True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.