diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index fab8c1f..fec416a 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -1,7 +1,7 @@ // See https://aka.ms/vscode-remote/devcontainer.json for format details. { - "image": "ludeeus/container:integration-debian", - "name": "Blueprint integration development", + "image": "ghcr.io/ludeeus/devcontainer/integration:stable", + "name": "FPL integration development", "context": "..", "appPort": [ "9123:8123" diff --git a/.github/workflows/cron.yaml b/.github/workflows/cron.yaml index 8d51d0f..4d520cc 100644 --- a/.github/workflows/cron.yaml +++ b/.github/workflows/cron.yaml @@ -1,8 +1,8 @@ name: Cron actions -on: - schedule: - - cron: '0 0 * * *' +#on: + #schedule: + #- cron: '0 0 * * *' jobs: validate: diff --git a/.gitignore b/.gitignore index e719a55..9fc1dff 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,5 @@ custom_components/fpl/__pycache__/ .vscode/launch.json test.py + +custom_components/fpl1/__pycache__/ diff --git a/.vscode/settings.json b/.vscode/settings.json index a3d535d..4224bfc 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -2,6 +2,10 @@ "python.linting.pylintEnabled": true, "python.linting.enabled": true, "python.pythonPath": "/usr/local/bin/python", + "python.linting.pylintArgs": [ + "--disable=C0103", + "--max-line-length=200" + ], "files.associations": { "*.yaml": "home-assistant" } diff --git a/custom_components/fpl/ProjectedBillSensor.py b/custom_components/fpl/ProjectedBillSensor.py deleted file mode 100644 index 8945dd0..0000000 --- a/custom_components/fpl/ProjectedBillSensor.py +++ /dev/null @@ -1,36 +0,0 @@ -from .FplSensor import FplSensor - - -class FplProjectedBillSensor(FplSensor): - def __init__(self, hass, config, account): - FplSensor.__init__(self, hass, config, account, "Projected Bill") - - @property - def state(self): - data = self.data - try: - if "budget_bill" in data.keys(): - if data["budget_bill"]: - if "budget_billing_projected_bill" in data.keys(): - self._state = data["budget_billing_projected_bill"] - else: - if "projected_bill" in data.keys(): - self._state = data["projected_bill"] - except: - pass - - return self._state - - @property - def device_state_attributes(self): - """Return the state attributes.""" - - if "budget_bill" in self.data.keys(): - self.attr["budget_bill"] = self.data["budget_bill"] - - - return self._state - - @property - def icon(self): - return "mdi:currency-usd" \ No newline at end of file diff --git a/custom_components/fpl/__init__.py b/custom_components/fpl/__init__.py index 18af9fe..5fe15f4 100644 --- a/custom_components/fpl/__init__.py +++ b/custom_components/fpl/__init__.py @@ -61,7 +61,7 @@ async def async_setup_entry(hass, entry): password = entry.data.get(CONF_PASSWORD) # Configure the client. - _LOGGER.info(f"Configuring the client") + _LOGGER.info("Configuring the client") session = async_get_clientsession(hass) client = FplApi(username, password, session) @@ -77,7 +77,7 @@ async def async_setup_entry(hass, entry): hass.config_entries.async_forward_entry_setup(entry, platform) ) - """Set up Fpl as config entry.""" + # Set up Fpl as config entry. entry.add_update_listener(async_reload_entry) return True diff --git a/custom_components/fpl/config_flow.py b/custom_components/fpl/config_flow.py index b94d54d..707ee6d 100644 --- a/custom_components/fpl/config_flow.py +++ b/custom_components/fpl/config_flow.py @@ -1,21 +1,22 @@ +"""Home Assistant Fpl integration Config Flow""" from collections import OrderedDict import voluptuous as vol -from .fplapi import FplApi from homeassistant import config_entries from homeassistant.helpers.aiohttp_client import async_create_clientsession +from homeassistant.core import callback from .const import DOMAIN, CONF_USERNAME, CONF_PASSWORD, CONF_NAME from .fplapi import ( LOGIN_RESULT_OK, + LOGIN_RESULT_FAILURE, LOGIN_RESULT_INVALIDUSER, LOGIN_RESULT_INVALIDPASSWORD, + FplApi, ) -from homeassistant.core import callback - @callback def configured_instances(hass): @@ -27,6 +28,7 @@ def configured_instances(hass): class FplFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): + """Fpl Config Flow Handler""" VERSION = 1 CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL @@ -57,8 +59,9 @@ class FplFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): result = await api.login() if result == LOGIN_RESULT_OK: - fplData = await api.async_get_data() - accounts = fplData["accounts"] + + accounts = await api.async_get_open_accounts() + await api.logout() user_input["accounts"] = accounts @@ -70,8 +73,8 @@ class FplFlowHandler(config_entries.ConfigFlow, domain=DOMAIN): if result == LOGIN_RESULT_INVALIDPASSWORD: self._errors[CONF_PASSWORD] = "invalid_password" - if result == None: - self._errors["base"] = "auth" + if result == LOGIN_RESULT_FAILURE: + self._errors["base"] = "failure" else: self._errors[CONF_NAME] = "name_exists" diff --git a/custom_components/fpl/const.py b/custom_components/fpl/const.py index 5a418bb..cb9ee79 100644 --- a/custom_components/fpl/const.py +++ b/custom_components/fpl/const.py @@ -3,7 +3,7 @@ NAME = "FPL Integration" DOMAIN = "fpl" DOMAIN_DATA = f"{DOMAIN}_data" -VERSION = "0.1.0" +VERSION = "0.0.1" PLATFORMS = ["sensor"] REQUIRED_FILES = [ ".translations/en.json", @@ -12,10 +12,9 @@ REQUIRED_FILES = [ "config_flow.py", "manifest.json", "sensor.py", - "switch.py", ] ISSUE_URL = "https://github.com/dotKrad/hass-fpl/issues" -ATTRIBUTION = "This data is provided by FPL." +ATTRIBUTION = "Data provided by FPL." # Platforms BINARY_SENSOR = "binary_sensor" diff --git a/custom_components/fpl/fplDataUpdateCoordinator.py b/custom_components/fpl/fplDataUpdateCoordinator.py index 5679cbf..01a5bc4 100644 --- a/custom_components/fpl/fplDataUpdateCoordinator.py +++ b/custom_components/fpl/fplDataUpdateCoordinator.py @@ -1,8 +1,10 @@ +"""Data Update Coordinator""" import logging +from datetime import timedelta from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed from homeassistant.core import HomeAssistant -from datetime import timedelta + from .fplapi import FplApi from .const import DOMAIN diff --git a/custom_components/fpl/fplEntity.py b/custom_components/fpl/fplEntity.py index 01c543c..91b0553 100644 --- a/custom_components/fpl/fplEntity.py +++ b/custom_components/fpl/fplEntity.py @@ -1,4 +1,7 @@ -"""BlueprintEntity class""" +"""Fpl Entity class""" + +from datetime import datetime, timedelta + from homeassistant.components.sensor import SensorEntity, STATE_CLASS_MEASUREMENT from homeassistant.helpers.update_coordinator import CoordinatorEntity @@ -7,14 +10,13 @@ from homeassistant.const import ( DEVICE_CLASS_ENERGY, ENERGY_KILO_WATT_HOUR, DEVICE_CLASS_MONETARY, - DEVICE_CLASS_TIMESTAMP, ) - -from datetime import datetime, timedelta from .const import DOMAIN, VERSION, ATTRIBUTION class FplEntity(CoordinatorEntity, SensorEntity): + """FPL base entity""" + def __init__(self, coordinator, config_entry, account, sensorName): super().__init__(coordinator) self.config_entry = config_entry @@ -24,22 +26,25 @@ class FplEntity(CoordinatorEntity, SensorEntity): @property def unique_id(self): """Return the ID of this device.""" - id = "{}{}{}".format( + return "{}{}{}".format( DOMAIN, self.account, self.sensorName.lower().replace(" ", "") ) - return id + + @property + def name(self): + return f"{DOMAIN.upper()} {self.account} {self.sensorName}" @property def device_info(self): return { "identifiers": {(DOMAIN, self.account)}, "name": f"FPL Account {self.account}", - "model": "FPL Monitoring API", - "sw_version": VERSION, + "model": VERSION, "manufacturer": "Florida Power & Light", } - def defineAttributes(self): + def customAttributes(self) -> dict: + """override this method to set custom attributes""" return {} @property @@ -49,16 +54,16 @@ class FplEntity(CoordinatorEntity, SensorEntity): "attribution": ATTRIBUTION, "integration": "FPL", } - attributes.update(self.defineAttributes()) + attributes.update(self.customAttributes()) return attributes def getData(self, field): - return self.coordinator.data.get(self.account).get(field) + """call this method to retrieve sensor data""" + return self.coordinator.data.get(self.account).get(field, None) class FplEnergyEntity(FplEntity): - def __init__(self, coordinator, config_entry, account, sensorName): - super().__init__(coordinator, config_entry, account, sensorName) + """Represents a energy sensor""" @property def state_class(self) -> str: @@ -90,8 +95,7 @@ class FplEnergyEntity(FplEntity): class FplMoneyEntity(FplEntity): - def __init__(self, coordinator, config_entry, account, sensorName): - super().__init__(coordinator, config_entry, account, sensorName) + """Represents a money sensor""" @property def icon(self): @@ -109,14 +113,31 @@ class FplMoneyEntity(FplEntity): class FplDateEntity(FplEntity): - def __init__(self, coordinator, config_entry, account, sensorName): - super().__init__(coordinator, config_entry, account, sensorName) + """Represents a date or days""" # @property # def device_class(self) -> str: # """Return the class of this device, from component DEVICE_CLASSES.""" - # return DEVICE_CLASS_TIMESTAMP + # return DEVICE_CLASS_DATE @property def icon(self): - return "mdi:calendar" \ No newline at end of file + return "mdi:calendar" + + +class FplDayEntity(FplEntity): + """Represents a date or days""" + + # @property + # def device_class(self) -> str: + # """Return the class of this device, from component DEVICE_CLASSES.""" + # return DEVICE_CLASS_DATE + + @property + def icon(self): + return "mdi:calendar" + + @property + def unit_of_measurement(self) -> str: + """Return the unit of measurement of this entity, if any.""" + return "days" diff --git a/custom_components/fpl/fplapi.py b/custom_components/fpl/fplapi.py index 857b35a..ef02114 100644 --- a/custom_components/fpl/fplapi.py +++ b/custom_components/fpl/fplapi.py @@ -1,13 +1,11 @@ +"""Custom FPl api client""" import logging -from datetime import datetime +from datetime import datetime, timedelta +import sys +import json import aiohttp import async_timeout -import json -import sys - - -# from bs4 import BeautifulSoup STATUS_CATEGORY_OPEN = "OPEN" # Api login result @@ -18,18 +16,40 @@ LOGIN_RESULT_UNAUTHORIZED = "UNAUTHORIZED" LOGIN_RESULT_FAILURE = "FAILURE" _LOGGER = logging.getLogger(__package__) -TIMEOUT = 30 +TIMEOUT = 5 + +API_HOST = "https://www.fpl.com" + +URL_LOGIN = API_HOST + "/api/resources/login" +URL_LOGOUT = API_HOST + "/api/resources/logout" +URL_RESOURCES_HEADER = API_HOST + "/api/resources/header" +URL_RESOURCES_ACCOUNT = API_HOST + "/api/resources/account/{account}" +URL_BUDGET_BILLING_GRAPH = ( + API_HOST + "/api/resources/account/{account}/budgetBillingGraph" +) + +URL_RESOURCES_PROJECTED_BILL = ( + API_HOST + + "/api/resources/account/{account}/projectedBill" + + "?premiseNumber={premise}&lastBilledDate={lastBillDate}" +) + +URL_ENERGY_SERVICE = ( + API_HOST + "/dashboard-api/resources/account/{account}/energyService/{account}" +) +URL_APPLIANCE_USAGE = ( + API_HOST + "/dashboard-api/resources/account/{account}/applianceUsage/{account}" +) +URL_BUDGET_BILLING_PREMISE_DETAILS = ( + API_HOST + "/api/resources/account/{account}/budgetBillingGraph/premiseDetails" +) -URL_LOGIN = "https://www.fpl.com/api/resources/login" -URL_RESOURCES_HEADER = "https://www.fpl.com/api/resources/header" -URL_RESOURCES_ACCOUNT = "https://www.fpl.com/api/resources/account/{account}" -URL_RESOURCES_PROJECTED_BILL = "https://www.fpl.com/api/resources/account/{account}/projectedBill?premiseNumber={premise}&lastBilledDate={lastBillDate}" ENROLLED = "ENROLLED" NOTENROLLED = "NOTENROLLED" -class FplApi(object): +class FplApi: """A class for getting energy usage information from Florida Power & Light.""" def __init__(self, username, password, session): @@ -39,7 +59,7 @@ class FplApi(object): self._session = session async def async_get_data(self) -> dict: - # self._session = aiohttp.ClientSession() + """Get data from fpl api""" data = {} data["accounts"] = [] if await self.login() == LOGIN_RESULT_OK: @@ -47,130 +67,151 @@ class FplApi(object): data["accounts"] = accounts for account in accounts: - accountData = await self.__async_get_data(account) - data[account] = accountData + account_data = await self.__async_get_data(account) + data[account] = account_data await self.logout() return data async def login(self): + """login into fpl""" _LOGGER.info("Logging in") # login and get account information - result = LOGIN_RESULT_OK try: async with async_timeout.timeout(TIMEOUT): response = await self._session.get( URL_LOGIN, auth=aiohttp.BasicAuth(self._username, self._password) ) - js = json.loads(await response.text()) + if response.status == 200: + _LOGGER.info("Logging Successful") + return LOGIN_RESULT_OK - if response.reason == "Unauthorized": - result = LOGIN_RESULT_UNAUTHORIZED + if response.status == 401: + _LOGGER.error("Logging Unauthorized") + json_data = json.loads(await response.text()) - if js["messages"][0]["messageCode"] != "login.success": - _LOGGER.error(f"Logging Failure") - result = LOGIN_RESULT_FAILURE + if json_data["messageCode"] == LOGIN_RESULT_INVALIDUSER: + return LOGIN_RESULT_INVALIDUSER - _LOGGER.info(f"Logging Successful") + if json_data["messageCode"] == LOGIN_RESULT_INVALIDPASSWORD: + return LOGIN_RESULT_INVALIDPASSWORD - except Exception as e: - _LOGGER.error(f"Error {e} : {sys.exc_info()[0]}") - result = LOGIN_RESULT_FAILURE + except Exception as exception: + _LOGGER.error("Error %s : %s", exception, sys.exc_info()[0]) + return LOGIN_RESULT_FAILURE - return result + return LOGIN_RESULT_FAILURE async def logout(self): + """Logging out from fpl""" _LOGGER.info("Logging out") - URL = "https://www.fpl.com/api/resources/logout" - async with async_timeout.timeout(TIMEOUT): - await self._session.get(URL) + try: + async with async_timeout.timeout(TIMEOUT): + await self._session.get(URL_LOGOUT) + except Exception: + pass async def async_get_open_accounts(self): - _LOGGER.info(f"Getting accounts") + """Getting open accounts""" + _LOGGER.info("Getting open accounts") result = [] try: async with async_timeout.timeout(TIMEOUT): response = await self._session.get(URL_RESOURCES_HEADER) - js = await response.json() - accounts = js["data"]["accounts"]["data"]["data"] + json_data = await response.json() + accounts = json_data["data"]["accounts"]["data"]["data"] for account in accounts: if account["statusCategory"] == STATUS_CATEGORY_OPEN: result.append(account["accountNumber"]) - except Exception as e: - _LOGGER.error(f"Getting accounts {e}") - # self._account_number = js["data"]["selectedAccount"]["data"]["accountNumber"] - # self._premise_number = js["data"]["selectedAccount"]["data"]["acctSecSettings"]["premiseNumber"] + except Exception: + _LOGGER.error("Getting accounts %s", sys.exc_info()) + return result async def __async_get_data(self, account) -> dict: - _LOGGER.info(f"Getting Data") + """Get data from resources endpoint""" + _LOGGER.info("Getting Data") data = {} async with async_timeout.timeout(TIMEOUT): response = await self._session.get( URL_RESOURCES_ACCOUNT.format(account=account) ) - accountData = (await response.json())["data"] + account_data = (await response.json())["data"] - premise = accountData["premiseNumber"].zfill(9) + premise = account_data.get("premiseNumber").zfill(9) + + data["meterSerialNo"] = account_data["meterSerialNo"] # currentBillDate currentBillDate = datetime.strptime( - accountData["currentBillDate"].replace("-", "").split("T")[0], "%Y%m%d" + account_data["currentBillDate"].replace("-", "").split("T")[0], "%Y%m%d" ).date() # nextBillDate nextBillDate = datetime.strptime( - accountData["nextBillDate"].replace("-", "").split("T")[0], "%Y%m%d" + account_data["nextBillDate"].replace("-", "").split("T")[0], "%Y%m%d" ).date() data["current_bill_date"] = str(currentBillDate) data["next_bill_date"] = str(nextBillDate) today = datetime.now().date() - remaining = (nextBillDate - today).days - days = (today - currentBillDate).days data["service_days"] = (nextBillDate - currentBillDate).days - data["as_of_days"] = days - data["remaining_days"] = remaining + data["as_of_days"] = (today - currentBillDate).days + data["remaining_days"] = (nextBillDate - today).days # zip code - zip_code = accountData["serviceAddress"]["zip"] + # zip_code = accountData["serviceAddress"]["zip"] # projected bill pbData = await self.__getFromProjectedBill(account, premise, currentBillDate) data.update(pbData) # programs - programsData = accountData["programs"]["data"] + programsData = account_data["programs"]["data"] programs = dict() - _LOGGER.info(f"Getting Programs") + _LOGGER.info("Getting Programs") for program in programsData: if "enrollmentStatus" in program.keys(): key = program["name"] programs[key] = program["enrollmentStatus"] == ENROLLED - if programs["BBL"]: - # budget billing - data["budget_bill"] = True - bblData = await self.__getBBL_async(account, data) - data.update(bblData) + def hasProgram(programName) -> bool: + return programName in programs and programs[programName] + # Budget Billing program + if hasProgram("BBL"): + data["budget_bill"] = True + bbl_data = await self.__getBBL_async(account, data) + data.update(bbl_data) + else: + data["budget_bill"] = False + + # Get data from energy service data.update( await self.__getDataFromEnergyService(account, premise, currentBillDate) ) + # Get data from energy service ( hourly ) + # data.update( + # await self.__getDataFromEnergyServiceHourly( + # account, premise, currentBillDate + # ) + # ) + data.update(await self.__getDataFromApplianceUsage(account, currentBillDate)) return data async def __getFromProjectedBill(self, account, premise, currentBillDate) -> dict: + """get data from projected bill endpoint""" data = {} try: @@ -196,24 +237,26 @@ class FplApi(object): data["projected_bill"] = projectedBill data["daily_avg"] = dailyAvg data["avg_high_temp"] = avgHighTemp - except: + + except Exception: pass return data async def __getBBL_async(self, account, projectedBillData) -> dict: - _LOGGER.info(f"Getting budget billing data") + """Get budget billing data""" + _LOGGER.info("Getting budget billing data") data = {} - - URL = "https://www.fpl.com/api/resources/account/{account}/budgetBillingGraph/premiseDetails" try: async with async_timeout.timeout(TIMEOUT): - response = await self._session.get(URL.format(account=account)) + response = await self._session.get( + URL_BUDGET_BILLING_PREMISE_DETAILS.format(account=account) + ) if response.status == 200: r = (await response.json())["data"] dataList = r["graphData"] - startIndex = len(dataList) - 1 + # startIndex = len(dataList) - 1 billingCharge = 0 budgetBillDeferBalance = r["defAmt"] @@ -235,28 +278,29 @@ class FplApi(object): data["budget_billing_bill_to_date"] = bbAsOfDateAmt data["budget_billing_projected_bill"] = float(projectedBudgetBill) - except: - pass - URL = "https://www.fpl.com/api/resources/account/{account}/budgetBillingGraph" + except Exception as e: + _LOGGER.error("Error getting BBL: %s", e) try: async with async_timeout.timeout(TIMEOUT): - response = await self._session.get(URL.format(account=account)) + response = await self._session.get( + URL_BUDGET_BILLING_GRAPH.format(account=account) + ) if response.status == 200: r = (await response.json())["data"] data["bill_to_date"] = float(r["eleAmt"]) data["defered_amount"] = float(r["defAmt"]) - except: - pass + + except Exception as e: + _LOGGER.error("Error getting BBL: %s", e) return data async def __getDataFromEnergyService( self, account, premise, lastBilledDate ) -> dict: - _LOGGER.info(f"Getting data from energy service") - URL = "https://www.fpl.com/dashboard-api/resources/account/{account}/energyService/{account}" + _LOGGER.info("Getting data from energy service") date = str(lastBilledDate.strftime("%m%d%Y")) JSON = { @@ -278,7 +322,9 @@ class FplApi(object): data = {} async with async_timeout.timeout(TIMEOUT): - response = await self._session.post(URL.format(account=account), json=JSON) + response = await self._session.post( + URL_ENERGY_SERVICE.format(account=account), json=JSON + ) if response.status == 200: r = (await response.json())["data"] dailyUsage = [] @@ -294,15 +340,21 @@ class FplApi(object): ): dailyUsage.append( { - "usage": daily.get("kwhUsed"), - "cost": daily.get("billingCharge"), - "date": daily.get("date"), - "max_temperature": daily.get( - "averageHighTemperature" + "usage": daily["kwhUsed"], + "cost": daily["billingCharge"], + # "date": daily["date"], + "max_temperature": daily["averageHighTemperature"], + "netDeliveredKwh": daily["netDeliveredKwh"] + if "netDeliveredKwh" in daily.keys() + else 0, + "netReceivedKwh": daily["netReceivedKwh"] + if "netReceivedKwh" in daily.keys() + else 0, + "readTime": datetime.fromisoformat( + daily[ + "readTime" + ] # 2022-02-25T00:00:00.000-05:00 ), - "netDeliveredKwh": daily.get("netDeliveredKwh"), - "netReceivedKwh": daily.get("netReceivedKwh"), - "readTime": daily.get("readTime"), } ) # totalPowerUsage += int(daily["kwhUsed"]) @@ -310,23 +362,103 @@ class FplApi(object): # data["total_power_usage"] = totalPowerUsage data["daily_usage"] = dailyUsage - data["projectedKWH"] = r["CurrentUsage"].get("projectedKWH") - data["dailyAverageKWH"] = r["CurrentUsage"].get("dailyAverageKWH") - data["billToDateKWH"] = r["CurrentUsage"].get("billToDateKWH") - data["recMtrReading"] = r["CurrentUsage"].get("recMtrReading") - data["delMtrReading"] = r["CurrentUsage"].get("delMtrReading") - data["billStartDate"] = r["CurrentUsage"].get("billStartDate") + data["projectedKWH"] = r["CurrentUsage"]["projectedKWH"] + data["dailyAverageKWH"] = r["CurrentUsage"]["dailyAverageKWH"] + data["billToDateKWH"] = r["CurrentUsage"]["billToDateKWH"] + data["recMtrReading"] = r["CurrentUsage"]["recMtrReading"] + data["delMtrReading"] = r["CurrentUsage"]["delMtrReading"] + data["billStartDate"] = r["CurrentUsage"]["billStartDate"] + return data + + async def __getDataFromEnergyServiceHourly( + self, account, premise, lastBilledDate + ) -> dict: + _LOGGER.info("Getting data from energy service Hourly") + + # date = str(lastBilledDate.strftime("%m%d%Y")) + date = str((datetime.now() - timedelta(days=1)).strftime("%m%d%Y")) + + JSON = { + "status": 2, + "channel": "WEB", + "amrFlag": "Y", + "accountType": "RESIDENTIAL", + "revCode": "1", + "premiseNumber": premise, + "projectedBillFlag": False, + "billComparisionFlag": False, + "monthlyFlag": False, + "frequencyType": "Hourly", + "applicationPage": "resDashBoard", + "startDate": date, + } + + data = {} + + # now = homeassistant.util.dt.utcnow() + + # now = datetime.now().astimezone() + # hour = now.hour + + async with async_timeout.timeout(TIMEOUT): + response = await self._session.post( + URL_ENERGY_SERVICE.format(account=account), json=JSON + ) + if response.status == 200: + r = (await response.json())["data"] + dailyUsage = [] + + # totalPowerUsage = 0 + if "data" in r["HourlyUsage"]: + for daily in r["HourlyUsage"]["data"]: + if ( + "kwhUsed" in daily.keys() + and "billingCharge" in daily.keys() + and "date" in daily.keys() + and "averageHighTemperature" in daily.keys() + ): + dailyUsage.append( + { + "usage": daily["kwhUsed"], + "cost": daily["billingCharge"], + # "date": daily["date"], + "max_temperature": daily["averageHighTemperature"], + "netDeliveredKwh": daily["netDeliveredKwh"] + if "netDeliveredKwh" in daily.keys() + else 0, + "netReceivedKwh": daily["netReceivedKwh"] + if "netReceivedKwh" in daily.keys() + else 0, + "readTime": datetime.fromisoformat( + daily[ + "readTime" + ] # 2022-02-25T00:00:00.000-05:00 + ), + } + ) + # totalPowerUsage += int(daily["kwhUsed"]) + + # data["total_power_usage"] = totalPowerUsage + data["daily_usage"] = dailyUsage + + data["projectedKWH"] = r["HourlyUsage"]["projectedKWH"] + data["dailyAverageKWH"] = r["HourlyUsage"]["dailyAverageKWH"] + data["billToDateKWH"] = r["HourlyUsage"]["billToDateKWH"] + data["recMtrReading"] = r["HourlyUsage"]["recMtrReading"] + data["delMtrReading"] = r["HourlyUsage"]["delMtrReading"] + data["billStartDate"] = r["HourlyUsage"]["billStartDate"] return data async def __getDataFromApplianceUsage(self, account, lastBilledDate) -> dict: - _LOGGER.info(f"Getting data from applicance usage") - URL = "https://www.fpl.com/dashboard-api/resources/account/{account}/applianceUsage/{account}" + """get data from appliance usage""" + _LOGGER.info("Getting data from appliance usage") + JSON = {"startDate": str(lastBilledDate.strftime("%m%d%Y"))} data = {} try: async with async_timeout.timeout(TIMEOUT): response = await self._session.post( - URL.format(account=account), json=JSON + URL_APPLIANCE_USAGE.format(account=account), json=JSON ) if response.status == 200: electric = (await response.json())["data"]["electric"] @@ -340,7 +472,7 @@ class FplApi(object): rr = full data[e["category"].replace(" ", "_")] = rr - except: + except Exception: pass return {"energy_percent_by_applicance": data} diff --git a/custom_components/fpl/manifest.json b/custom_components/fpl/manifest.json index ec5fb6d..0397962 100644 --- a/custom_components/fpl/manifest.json +++ b/custom_components/fpl/manifest.json @@ -12,6 +12,5 @@ "integrationhelper" ], "version": "1.0.0", - "issue_tracker": "https://github.com/dotKrad/hass-fpl/issues", - "homeassistant": "2021.12.7" + "issue_tracker": "https://github.com/dotKrad/hass-fpl/issues" } \ No newline at end of file diff --git a/custom_components/fpl/sensor.py b/custom_components/fpl/sensor.py index 6c6ff5c..45bb018 100644 --- a/custom_components/fpl/sensor.py +++ b/custom_components/fpl/sensor.py @@ -21,8 +21,9 @@ from .sensor_ProjectedBillSensor import ( DeferedAmountSensor, ) from .sensor_AverageDailySensor import ( - FplAverageDailySensor, + DailyAverageSensor, BudgetDailyAverageSensor, + ActualDailyAverageSensor, ) from .sensor_DailyUsageSensor import ( FplDailyUsageKWHSensor, @@ -30,10 +31,9 @@ from .sensor_DailyUsageSensor import ( FplDailyDeliveredKWHSensor, FplDailyReceivedKWHSensor, ) - from .const import DOMAIN -from .TestSensor import TestSensor +# from .TestSensor import TestSensor async def async_setup_entry(hass, entry, async_add_devices): @@ -54,12 +54,12 @@ async def async_setup_entry(hass, entry, async_add_devices): fpl_accounts.append(DeferedAmountSensor(coordinator, entry, account)) # usage sensors - fpl_accounts.append(FplAverageDailySensor(coordinator, entry, account)) + fpl_accounts.append(DailyAverageSensor(coordinator, entry, account)) fpl_accounts.append(BudgetDailyAverageSensor(coordinator, entry, account)) + fpl_accounts.append(ActualDailyAverageSensor(coordinator, entry, account)) + fpl_accounts.append(FplDailyUsageSensor(coordinator, entry, account)) fpl_accounts.append(FplDailyUsageKWHSensor(coordinator, entry, account)) - fpl_accounts.append(FplDailyReceivedKWHSensor(coordinator, entry, account)) - fpl_accounts.append(FplDailyDeliveredKWHSensor(coordinator, entry, account)) # date sensors fpl_accounts.append(CurrentBillDateSensor(coordinator, entry, account)) @@ -72,11 +72,11 @@ async def async_setup_entry(hass, entry, async_add_devices): fpl_accounts.append(ProjectedKWHSensor(coordinator, entry, account)) fpl_accounts.append(DailyAverageKWHSensor(coordinator, entry, account)) fpl_accounts.append(BillToDateKWHSensor(coordinator, entry, account)) - fpl_accounts.append(NetReceivedKWHSensor(coordinator, entry, account)) - fpl_accounts.append(NetDeliveredKWHSensor(coordinator, entry, account)) - fpl_accounts.append(NetReceivedKWHSensor(coordinator, entry, account)) fpl_accounts.append(NetDeliveredKWHSensor(coordinator, entry, account)) + fpl_accounts.append(FplDailyReceivedKWHSensor(coordinator, entry, account)) + fpl_accounts.append(FplDailyDeliveredKWHSensor(coordinator, entry, account)) + async_add_devices(fpl_accounts) diff --git a/custom_components/fpl/sensor_AllData.py b/custom_components/fpl/sensor_AllData.py deleted file mode 100644 index d8395fd..0000000 --- a/custom_components/fpl/sensor_AllData.py +++ /dev/null @@ -1,33 +0,0 @@ -from .fplEntity import FplEntity - - -class AllDataSensor(FplEntity): - def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "") - - @property - def state(self): - budget = self.getData("budget_bill") - budget_billing_projected_bill = self.getData("budget_billing_projected_bill") - - if budget == True and budget_billing_projected_bill is not None: - return self.getData("budget_billing_projected_bill") - - try: - self._state=self.getData("projected_bill") - except: - pass - return self._state - - @property - def icon(self): - return "mdi:currency-usd" - - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["friendly_name"] = "Budget Projected Bill" - attributes["device_class"] = "monetary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" - return attributes \ No newline at end of file diff --git a/custom_components/fpl/sensor_AverageDailySensor.py b/custom_components/fpl/sensor_AverageDailySensor.py index 6665ced..f997c0c 100644 --- a/custom_components/fpl/sensor_AverageDailySensor.py +++ b/custom_components/fpl/sensor_AverageDailySensor.py @@ -1,7 +1,11 @@ +"""Average daily sensors""" +from homeassistant.components.sensor import STATE_CLASS_TOTAL from .fplEntity import FplMoneyEntity -class FplAverageDailySensor(FplMoneyEntity): +class DailyAverageSensor(FplMoneyEntity): + """average daily sensor, use budget value if available, otherwise use actual daily values""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Average") @@ -10,64 +14,47 @@ class FplAverageDailySensor(FplMoneyEntity): budget = self.getData("budget_bill") budget_billing_projected_bill = self.getData("budget_billing_daily_avg") - if budget == True and budget_billing_projected_bill is not None: + if budget and budget_billing_projected_bill is not None: return self.getData("budget_billing_daily_avg") - try: - self._state=self.getData("daily_avg") - except: - pass - return self._state + return self.getData("daily_avg") -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:currency-usd" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Daily Average" - attributes["device_class"] = "monetary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes ->>>>>>> master + class BudgetDailyAverageSensor(FplMoneyEntity): + """budget daily average sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Budget Daily Average") @property def state(self): - try: - self._state= self.getData("budget_billing_daily_avg") - except: - pass - return self._state + return self.getData("budget_billing_daily_avg") + + def customAttributes(self): + """Return the state attributes.""" + attributes = {} + attributes["state_class"] = STATE_CLASS_TOTAL + return attributes -<<<<<<< HEAD class ActualDailyAverageSensor(FplMoneyEntity): + """Actual daily average sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Actual Daily Average") @property def state(self): return self.getData("daily_avg") -======= - @property - def icon(self): - return "mdi:currency-usd" - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Budget Daily Average" - attributes["device_class"] = "monitary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes - ->>>>>>> master diff --git a/custom_components/fpl/sensor_DailyUsageSensor.py b/custom_components/fpl/sensor_DailyUsageSensor.py index 23ab8ed..e3888f7 100644 --- a/custom_components/fpl/sensor_DailyUsageSensor.py +++ b/custom_components/fpl/sensor_DailyUsageSensor.py @@ -1,7 +1,12 @@ +"""Daily Usage Sensors""" +from homeassistant.components.sensor import STATE_CLASS_TOTAL_INCREASING +from datetime import timedelta from .fplEntity import FplEnergyEntity, FplMoneyEntity class FplDailyUsageSensor(FplMoneyEntity): + """Daily Usage Cost Sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Usage") @@ -9,37 +14,25 @@ class FplDailyUsageSensor(FplMoneyEntity): def state(self): data = self.getData("daily_usage") - try: - self._state = data[-1]["cost"] - except: - pass - return self._state + if data is not None and len(data) > 0 and "cost" in data[-1].keys(): + return data[-1]["cost"] - def defineAttributes(self): + return None + + def customAttributes(self): """Return the state attributes.""" data = self.getData("daily_usage") attributes = {} - attributes["friendly_name"] = "Daily Usage" - attributes["device_class"] = "monetary" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "$" - if data is not None: - if ( - (len(data) > 0) - and (data[-1] is not None) - and (data[-1]["readTime"] is not None) - ): - attributes["date"] = data[-1]["readTime"] - if ( - (len(data) > 1) - and (data[-2] is not None) - and (data[-2]["readTime"] is not None) - ): - attributes["last_reset"] = data[-2]["readTime"] + # attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + if data is not None and len(data) > 0 and "readTime" in data[-1].keys(): + attributes["date"] = data[-1]["readTime"] + return attributes class FplDailyUsageKWHSensor(FplEnergyEntity): + """Daily Usage Kwh Sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Usage KWH") @@ -47,126 +40,71 @@ class FplDailyUsageKWHSensor(FplEnergyEntity): def state(self): data = self.getData("daily_usage") - try: - self._state = data[-1]["usage"] - except: - pass - return self._state + if data is not None and len(data) > 0 and "usage" in data[-1].keys(): + return data[-1]["usage"] - def defineAttributes(self): + return None + + def customAttributes(self): """Return the state attributes.""" data = self.getData("daily_usage") + date = data[-1]["readTime"] + last_reset = date - timedelta(days=1) attributes = {} - attributes["friendly_name"] = "Daily Usage" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - - if data is not None: - if ( - (len(data) > 0) - and (data[-1] is not None) - and (data[-1]["readTime"] is not None) - ): - attributes["date"] = data[-1]["readTime"] - if ( - (len(data) > 1) - and (data[-2] is not None) - and (data[-2]["readTime"] is not None) - ): - attributes["last_reset"] = data[-2]["readTime"] - + # attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + attributes["date"] = date + # attributes["last_reset"] = last_reset return attributes - @property - def icon(self): - return "mdi:flash" +class FplDailyReceivedKWHSensor(FplEnergyEntity): + """daily received Kwh sensor""" -class FplDailyReceivedKWHSensor(FplEntity): def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Received KWH") @property def state(self): data = self.getData("daily_usage") - try: - self._state = data[-1]["netReceivedKwh"] - except: - pass - return self._state + if data is not None and len(data) > 0 and "netReceivedKwh" in data[-1].keys(): + return data[-1]["netReceivedKwh"] + return 0 - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" data = self.getData("daily_usage") + date = data[-1]["readTime"] + last_reset = date - timedelta(days=1) attributes = {} - attributes["friendly_name"] = "Daily Return to Grid" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - if data is not None: - if ( - (len(data) > 0) - and (data[-1] is not None) - and (data[-1]["readTime"] is not None) - ): - attributes["date"] = data[-1]["readTime"] - if ( - (len(data) > 1) - and (data[-2] is not None) - and (data[-2]["readTime"] is not None) - ): - attributes["last_reset"] = data[-2]["readTime"] + attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + attributes["date"] = date + attributes["last_reset"] = last_reset return attributes - @property - def icon(self): - return "mdi:flash" +class FplDailyDeliveredKWHSensor(FplEnergyEntity): + """daily delivered Kwh sensor""" -class FplDailyDeliveredKWHSensor(FplEntity): def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Delivered KWH") @property def state(self): data = self.getData("daily_usage") - try: - self._state = data[-1]["netDeliveredKwh"] - except: - pass - return self._state + if data is not None and len(data) > 0 and "netDeliveredKwh" in data[-1].keys(): + return data[-1]["netDeliveredKwh"] + return 0 - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" data = self.getData("daily_usage") + date = data[-1]["readTime"] + last_reset = date - timedelta(days=1) -<<<<<<< HEAD - return {} -======= attributes = {} - attributes["friendly_name"] = "Daily Consumption" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - if data is not None: - if ( - (len(data) > 0) - and (data[-1] is not None) - and (data[-1]["readTime"] is not None) - ): - attributes["date"] = data[-1]["readTime"] - if ( - (len(data) > 1) - and (data[-2] is not None) - and (data[-2]["readTime"] is not None) - ): - attributes["last_reset"] = data[-2]["readTime"] + attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + attributes["date"] = date + attributes["last_reset"] = last_reset return attributes - - @property - def icon(self): - return "mdi:flash" ->>>>>>> master diff --git a/custom_components/fpl/sensor_DatesSensor.py b/custom_components/fpl/sensor_DatesSensor.py index 5762532..0a54844 100644 --- a/custom_components/fpl/sensor_DatesSensor.py +++ b/custom_components/fpl/sensor_DatesSensor.py @@ -1,136 +1,48 @@ -<<<<<<< HEAD -from .fplEntity import FplDateEntity - -======= -from .fplEntity import FplEntity +"""dates sensors""" import datetime ->>>>>>> master +from .fplEntity import FplDateEntity, FplDayEntity + class CurrentBillDateSensor(FplDateEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Billing Current Date") + super().__init__(coordinator, config, account, "Current Bill Date") @property def state(self): - try: - self._state= datetime.date.fromisoformat(self.getData("current_bill_date")) - except: - pass - return self._state + return datetime.date.fromisoformat(self.getData("current_bill_date")) -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:calendar" - - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["device_class"] = "date" - attributes["friendly_name"] = "Billing Current" - return attributes ->>>>>>> master class NextBillDateSensor(FplDateEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Billing Next") + super().__init__(coordinator, config, account, "Next Bill Date") @property def state(self): - try: - self._state= datetime.date.fromisoformat(self.getData("next_bill_date")) - except: - pass - return self._state + return datetime.date.fromisoformat(self.getData("next_bill_date")) -<<<<<<< HEAD -class ServiceDaysSensor(FplDateEntity): -======= - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["device_class"] = "date" - attributes["friendly_name"] = "Billing Next" - return attributes - -class ServiceDaysSensor(FplEntity): ->>>>>>> master +class ServiceDaysSensor(FplDayEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Billing Total Days") + super().__init__(coordinator, config, account, "Service Days") @property def state(self): - try: - self._state= self.getData("service_days") - except: - pass - return self._state + return self.getData("service_days") -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:calendar" - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["unit_of_measurement"] = "days" - attributes["friendly_name"] = "Billing Total" - return attributes ->>>>>>> master - -class AsOfDaysSensor(FplDateEntity): +class AsOfDaysSensor(FplDayEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Billing As Of") + super().__init__(coordinator, config, account, "As Of Days") @property def state(self): - try: - self._state= self.getData("as_of_days") - except: - pass - return self._state + return self.getData("as_of_days") -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:calendar" - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["unit_of_measurement"] = "days" - attributes["friendly_name"] = "Billing As Of" - return attributes ->>>>>>> master - -class RemainingDaysSensor(FplDateEntity): +class RemainingDaysSensor(FplDayEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Billing Remaining") + super().__init__(coordinator, config, account, "Remaining Days") @property def state(self): -<<<<<<< HEAD return self.getData("remaining_days") -======= - try: - self._state= self.getData("remaining_days") - except: - pass - return self._state - - @property - def icon(self): - return "mdi:calendar" - - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["unit_of_measurement"] = "days" - attributes["friendly_name"] = "Billing Remaining" - return attributes ->>>>>>> master diff --git a/custom_components/fpl/sensor_KWHSensor.py b/custom_components/fpl/sensor_KWHSensor.py index 00a70bc..c461cdd 100644 --- a/custom_components/fpl/sensor_KWHSensor.py +++ b/custom_components/fpl/sensor_KWHSensor.py @@ -1,157 +1,89 @@ -from homeassistant.components.sensor import STATE_CLASS_TOTAL_INCREASING +"""energy sensors""" +from datetime import date, timedelta +from homeassistant.components.sensor import ( + STATE_CLASS_TOTAL_INCREASING, + STATE_CLASS_TOTAL, +) from .fplEntity import FplEnergyEntity class ProjectedKWHSensor(FplEnergyEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Projected") + super().__init__(coordinator, config, account, "Projected KWH") @property def state(self): - try: - self._state = self.getData("projectedKWH") - except: - pass - return self._state + return self.getData("projectedKWH") - -<<<<<<< HEAD -class DailyAverageKWHSensor(FplEnergyEntity): -======= - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Projected KWH" - attributes["device_class"] = "energy" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "kWh" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes -class DailyAverageKWHSensor(FplEntity): ->>>>>>> master +class DailyAverageKWHSensor(FplEnergyEntity): def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Daily Average KWH") @property def state(self): - try: - self._state = self.getData("dailyAverageKWH") - except: - pass - return self._state + return self.getData("dailyAverageKWH") -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:flash" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Daily Average" - attributes["device_class"] = "energy" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "kWh" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes ->>>>>>> master class BillToDateKWHSensor(FplEnergyEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Bill To Date") + super().__init__(coordinator, config, account, "Bill To Date KWH") @property def state(self): - try: - self._state = self.getData("billToDateKWH") - except: - pass - return self._state + return self.getData("billToDateKWH") - @property - def state_class(self) -> str: - """Return the state class of this entity, from STATE_CLASSES, if any.""" - - -<<<<<<< HEAD -class NetReceivedKWHSensor(FplEnergyEntity): -======= - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" + + # data = self.getData("daily_usage") + # date = data[-1]["readTime"] + asOfDays = self.getData("as_of_days") + last_reset = date.today() - timedelta(days=asOfDays) + attributes = {} - attributes["friendly_name"] = "Billing Usage" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - if self.getData("billStartDate") is not None: - attributes["last_reset"] = self.getData("billStartDate") + attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + attributes["last_reset"] = last_reset return attributes -class NetReceivedKWHSensor(FplEntity): ->>>>>>> master +class NetReceivedKWHSensor(FplEnergyEntity): def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Received Reading") + super().__init__(coordinator, config, account, "Received Meter Reading KWH") @property def state(self): - try: - self._state = self.getData("recMtrReading") - except: - pass - return self._state + return self.getData("recMtrReading") - @property - def icon(self): - return "mdi:flash" + def customAttributes(self): + """Return the state attributes.""" + attributes = {} + attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING + return attributes -<<<<<<< HEAD class NetDeliveredKWHSensor(FplEnergyEntity): -======= - def defineAttributes(self): - """Return the state attributes.""" - attributes = {} - attributes["friendly_name"] = "Meter Return to Grid" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - if self.getData("billStartDate") is not None: - attributes["last_reset"] = self.getData("billStartDate") - - return attributes - - -class NetDeliveredKWHSensor(FplEntity): ->>>>>>> master def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Delivered Reading") + super().__init__(coordinator, config, account, "Delivered Meter Reading KWH") @property def state(self): - try: - self._state = self.getData("delMtrReading") - except: - try: - self._state = self.getData("billToDateKWH") - except: - pass - return self._state + return self.getData("delMtrReading") - @property - def icon(self): - return "mdi:flash" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Meter Consumption" - attributes["device_class"] = "energy" - attributes["state_class"] = "total_increasing" - attributes["unit_of_measurement"] = "kWh" - if self.getData("billStartDate") is not None: - attributes["last_reset"] = self.getData("billStartDate") - + attributes["state_class"] = STATE_CLASS_TOTAL_INCREASING return attributes diff --git a/custom_components/fpl/sensor_ProjectedBillSensor.py b/custom_components/fpl/sensor_ProjectedBillSensor.py index 35fc24f..264217a 100644 --- a/custom_components/fpl/sensor_ProjectedBillSensor.py +++ b/custom_components/fpl/sensor_ProjectedBillSensor.py @@ -1,120 +1,96 @@ +"""Projected bill sensors""" +from homeassistant.components.sensor import ( + # STATE_CLASS_TOTAL_INCREASING, + STATE_CLASS_TOTAL, +) from .fplEntity import FplMoneyEntity class FplProjectedBillSensor(FplMoneyEntity): + """projected bill sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Projected Bill") + @property + def native_value(self): + budget = self.getData("budget_bill") + budget_billing_projected_bill = self.getData("budget_billing_projected_bill") + + if budget and budget_billing_projected_bill is not None: + return self.getData("budget_billing_projected_bill") + + return self.getData("projected_bill") + + """ @property def state(self): budget = self.getData("budget_bill") budget_billing_projected_bill = self.getData("budget_billing_projected_bill") - try: - if budget == True and budget_billing_projected_bill is not None: - self._state = self.getData("budget_billing_projected_bill") - else: - self._state = self.getData("projected_bill") - except: - self._state = None - return self._state + if budget and budget_billing_projected_bill is not None: + return self.getData("budget_billing_projected_bill") - def defineAttributes(self): + return self.getData("projected_bill") + """ + + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Projected Bill Payment Due" - attributes["device_class"] = "monetary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" + attributes["state_class"] = STATE_CLASS_TOTAL + attributes["budget_bill"] = self.getData("budget_bill") return attributes # Defered Amount class DeferedAmountSensor(FplMoneyEntity): + """Defered amount sensor""" + def __init__(self, coordinator, config, account): - super().__init__(coordinator, config, account, "Deferred Amount") + super().__init__(coordinator, config, account, "Defered Amount") @property def state(self): - try: - self._state = self.getData("deferred_amount") - except: - self._state = 0 - pass - return self._state + if self.getData("budget_bill"): + return self.getData("defered_amount") + return 0 -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:currency-usd" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Deferred Amount" - attributes["device_class"] = "monetary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes ->>>>>>> master class ProjectedBudgetBillSensor(FplMoneyEntity): + """projected budget bill sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Projected Budget Bill") @property def state(self): - try: - self._state = self.getData("budget_billing_projected_bill") - except: - pass - return self._state + return self.getData("budget_billing_projected_bill") -<<<<<<< HEAD -======= - @property - def icon(self): - return "mdi:currency-usd" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Projected Budget Bill" - attributes["device_class"] = "monitary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" + attributes["state_class"] = STATE_CLASS_TOTAL return attributes ->>>>>>> master class ProjectedActualBillSensor(FplMoneyEntity): + """projeted actual bill sensor""" + def __init__(self, coordinator, config, account): super().__init__(coordinator, config, account, "Projected Actual Bill") @property def state(self): -<<<<<<< HEAD return self.getData("projected_bill") -======= - try: - self._state = self.getData("projected_bill") - except: - pass - return self._state - @property - def icon(self): - return "mdi:currency-usd" - - def defineAttributes(self): + def customAttributes(self): """Return the state attributes.""" attributes = {} - attributes["friendly_name"] = "Projected Actual Bill" - attributes["device_class"] = "monitary" - attributes["state_class"] = "total" - attributes["unit_of_measurement"] = "$" - + attributes["state_class"] = STATE_CLASS_TOTAL return attributes ->>>>>>> master diff --git a/custom_components/fpl/translations/en.json b/custom_components/fpl/translations/en.json index 8bcd4d0..0d954f4 100644 --- a/custom_components/fpl/translations/en.json +++ b/custom_components/fpl/translations/en.json @@ -13,6 +13,7 @@ } }, "error": { + "failure": "An error ocurred, please check the logs", "auth": "Username/Password is wrong.", "name_exists": "Configuration already exists.", "invalid_username": "Invalid Email",