async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Scrape from a config entry."""
resource: str = entry.options[CONF_RESOURCE]
method: str = "GET"
payload: str | None = None
headers: str | None = entry.options.get(CONF_HEADERS)
verify_ssl: bool = entry.options[CONF_VERIFY_SSL]
username: str | None = entry.options.get(CONF_USERNAME)
password: str | None = entry.options.get(CONF_PASSWORD)
auth: httpx.DigestAuth | tuple[str, str] | None = None
if username and password:
if entry.options.get(
CONF_AUTHENTICATION) == HTTP_DIGEST_AUTHENTICATION:
auth = httpx.DigestAuth(username, password)
else:
auth = (username, password)
rest = RestData(hass, method, resource, auth, headers, None, payload,
verify_ssl)
await rest.async_update()
if rest.data is None:
raise ConfigEntryNotReady
hass.data.setdefault(DOMAIN, {})[entry.entry_id] = rest
entry.async_on_unload(entry.add_update_listener(async_update_listener))
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the Web scrape sensor."""
name = config.get(CONF_NAME)
resource = config.get(CONF_RESOURCE)
method = "GET"
payload = None
headers = config.get(CONF_HEADERS)
verify_ssl = config.get(CONF_VERIFY_SSL)
select = config.get(CONF_SELECT)
attr = config.get(CONF_ATTR)
index = config.get(CONF_INDEX)
unit = config.get(CONF_UNIT_OF_MEASUREMENT)
username = config.get(CONF_USERNAME)
password = config.get(CONF_PASSWORD)
value_template = config.get(CONF_VALUE_TEMPLATE)
if value_template is not None:
value_template.hass = hass
if username and password:
if config.get(CONF_AUTHENTICATION) == HTTP_DIGEST_AUTHENTICATION:
auth = HTTPDigestAuth(username, password)
else:
auth = HTTPBasicAuth(username, password)
else:
auth = None
rest = RestData(method, resource, auth, headers, payload, verify_ssl)
await rest.async_update()
if rest.data is None:
raise PlatformNotReady
async_add_entities(
[ScrapeSensor(rest, name, select, attr, index, value_template, unit)], True
)
def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry):
"""Initialize the Feed Entity Manager."""
self._hass = hass
self._config_entry = config_entry
self._district_name = config_entry.data[CONF_DISTRICT_NAME]
self._config_entry_id = config_entry.entry_id
self._scan_interval = timedelta(
seconds=config_entry.data[CONF_SCAN_INTERVAL])
self._track_time_remove_callback = None
if MAJOR_VERSION >= 1 or MINOR_VERSION >= 119:
self._rest = RestData(DEFAULT_METHOD, URL, None, None, None, None,
DEFAULT_VERIFY_SSL)
else:
self._rest = RestData(DEFAULT_METHOD, URL, None, None, None,
DEFAULT_VERIFY_SSL)
self._attributes = None
async def add_sensors(hass,
config,
async_add_devices,
name,
location,
discovery_info=None):
method = "GET"
payload = ""
auth = None
verify_ssl = DEFAULT_VERIFY_SSL
headers = {}
params = {}
timeout = 5000
endpoint = _ENDPOINT + location
rest = RestData(hass, method, endpoint, auth, headers, payload, params,
verify_ssl, timeout)
await rest.async_update()
if rest.data is None:
_LOGGER.error("Unable to fetch data from Sjöfartsverket")
return False
_LOGGER.debug("rest.data: %s", rest.data)
restData = json.loads(rest.data)
sensors = []
location = restData["GetSingleStationResult"]["Name"]
for data in restData["GetSingleStationResult"]["Samples"]:
sensors.append(entityRepresentation(rest, name, location, data))
async_add_devices(sensors, True)
def updateRestData(self):
# changed to async, update deprecated
# RestData.update(self)
try:
asyncio.run_coroutine_threadsafe(RestData.async_update(self),
self._hass.loop).result(5)
self._lastUpdate = datetime.now()
except Exception as e:
_LOGGER.warning("updateRestData exception %s", e)
async def async_setup_platform(
hass: HomeAssistant,
config: ConfigType,
async_add_entities: AddEntitiesCallback,
discovery_info: DiscoveryInfoType | None = None,
) -> None:
"""Set up the Web scrape sensor."""
name: str = config[CONF_NAME]
resource: str = config[CONF_RESOURCE]
method: str = "GET"
payload: str | None = None
headers: str | None = config.get(CONF_HEADERS)
verify_ssl: bool = config[CONF_VERIFY_SSL]
select: str | None = config.get(CONF_SELECT)
attr: str | None = config.get(CONF_ATTR)
index: int = config[CONF_INDEX]
unit: str | None = config.get(CONF_UNIT_OF_MEASUREMENT)
device_class: str | None = config.get(CONF_DEVICE_CLASS)
state_class: str | None = config.get(CONF_STATE_CLASS)
username: str | None = config.get(CONF_USERNAME)
password: str | None = config.get(CONF_PASSWORD)
value_template: Template | None = config.get(CONF_VALUE_TEMPLATE)
if value_template is not None:
value_template.hass = hass
auth: httpx.DigestAuth | tuple[str, str] | None = None
if username and password:
if config.get(CONF_AUTHENTICATION) == HTTP_DIGEST_AUTHENTICATION:
auth = httpx.DigestAuth(username, password)
else:
auth = (username, password)
rest = RestData(hass, method, resource, auth, headers, None, payload,
verify_ssl)
await rest.async_update()
if rest.data is None:
raise PlatformNotReady
async_add_entities(
[
ScrapeSensor(
rest,
name,
select,
attr,
index,
value_template,
unit,
device_class,
state_class,
)
],
True,
)
def __init__(
self,
hass,
method,
resource,
auth,
headers,
data,
verify_ssl=False,
httptimeout=5,
cacheTimeout=20,
):
RestData.__init__(self, hass, method, resource, auth, headers, None,
data, verify_ssl, httptimeout)
self._lastUpdate = None
self._cacheTimeout = cacheTimeout
self._hass = hass
self._isUpdating = False
async def async_step_user(self, user_input: Optional[Dict[str, Any]] = None):
"""Invoked when a user initiates a flow via the user interface."""
_LOGGER.debug(f"async_step_user({user_input})")
errors: Dict[str, str] = {}
if user_input is not None:
try:
_LOGGER.debug("user_input not None")
if user_input[CONF_NAME] in configured_instances(self.hass, CONF_NAME):
raise ConfigFlowException("name_exists")
if user_input[CONF_WALLET] in configured_instances(
self.hass, CONF_WALLET
):
raise ConfigFlowException("wallet_exists")
resource = (
"https://web.xmrpool.eu:8119/stats_address?address="
+ user_input[CONF_WALLET]
)
rest = RestData(
self.hass,
"GET",
resource,
auth=None,
headers=None,
params=None,
data=None,
verify_ssl=True,
)
await rest.async_update()
if rest.data is None:
raise ConfigFlowException("no_answer")
data = json.loads(rest.data)
if "error" in data.keys():
_LOGGER.debug("Invalid answer: %s", data["error"])
raise ConfigFlowException("invalid_answer")
except ConfigFlowException as ex:
_LOGGER.warning("Configuration error: %s", ex.error)
errors["base"] = ex.error
except:
_LOGGER.warning("Unexpected exception")
errors["base"] = "unknown_exception"
raise
if not errors:
# Input is valid, set data.
self.data = user_input
return self.async_create_entry(
title=user_input[CONF_NAME], data=self.data
)
_LOGGER.debug("Show input form...")
return self.async_show_form(
step_id="user", data_schema=AUTH_SCHEMA, errors=errors
)
def __init__(self, hass):
self.hass = hass
self.rest = RestData(
self.hass,
DEFAULT_METHOD,
self.URL,
None,
None,
None,
None,
DEFAULT_VERIFY_SSL,
)
self._data = None
def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None:
"""Initialize the Feed Entity Manager."""
self.hass = hass
self._district_name = config_entry.data[CONF_DISTRICT_NAME]
self._rest = RestData(hass, DEFAULT_METHOD, URL_DATA, None, None, None,
None, DEFAULT_VERIFY_SSL)
super().__init__(
self.hass,
_LOGGER,
name=DOMAIN,
update_method=self.async_update,
update_interval=timedelta(
seconds=config_entry.data[CONF_SCAN_INTERVAL]),
)
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the PVOutput sensor."""
name = config.get(CONF_NAME)
api_key = config.get(CONF_API_KEY)
system_id = config.get(CONF_SYSTEM_ID)
method = "GET"
payload = auth = None
verify_ssl = DEFAULT_VERIFY_SSL
headers = {"X-Pvoutput-Apikey": api_key, "X-Pvoutput-SystemId": system_id}
rest = RestData(method, _ENDPOINT, auth, headers, None, payload, verify_ssl)
await rest.async_update()
if rest.data is None:
_LOGGER.error("Unable to fetch data from PVOutput")
return False
async_add_entities([PvoutputSensor(rest, name)], True)
def __init__(self, hass: HomeAssistant,
config_entry: config_entries.ConfigEntry) -> None:
"""Initialize controller"""
self._lock = asyncio.Lock()
self._hass = hass
self._name: str = config_entry.data[CONF_NAME]
self._scheduledUpdateCallback = None
resource = ("https://web.xmrpool.eu:8119/stats_address?address=" +
config_entry.data[CONF_WALLET])
self._rest = RestData(
self._hass,
"GET",
resource,
auth=None,
headers=None,
params=None,
data=None,
verify_ssl=True,
)
self._statData: Dict[str, Any] = None
self._workersData: Dict[str, Dict[str, Any]] = None
self.listeners = []
self.entity_id = config_entry.entry_id
state_class = config.get(CONF_STATE_CLASS)
username = config.get(CONF_USERNAME)
password = config.get(CONF_PASSWORD)
if (value_template := config.get(CONF_VALUE_TEMPLATE)) is not None:
value_template.hass = hass
auth: httpx.DigestAuth | tuple[str, str] | None
if username and password:
if config.get(CONF_AUTHENTICATION) == HTTP_DIGEST_AUTHENTICATION:
auth = httpx.DigestAuth(username, password)
else:
auth = (username, password)
else:
auth = None
rest = RestData(hass, method, resource, auth, headers, None, payload,
verify_ssl)
await rest.async_update()
if rest.data is None:
raise PlatformNotReady
async_add_entities(
[
ScrapeSensor(
rest,
name,
select,
attr,
index,
value_template,
unit,
