auroraplus 1.7.0__py3-none-any.whl

auroraplus/__init__.py

@@ -0,0 +1,12 @@
+from .api import AuroraPlusApi, AuroraPlusAuthenticationError, AuroraPlusToken, api
+from .get_token import get_token
+from .repl import repl
+
+__all__ = [
+    "AuroraPlusApi",
+    "AuroraPlusAuthenticationError",
+    "AuroraPlusToken",
+    "api",
+    "get_token",
+    "repl",
+]

auroraplus/api.py

@@ -0,0 +1,608 @@
+"""Abstraction of the Aurora+ API"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import logging
+import random
+import string
+import uuid
+from datetime import datetime
+from typing import Any, ClassVar, TypeAlias
+from warnings import deprecated
+
+from requests import Response
+from requests.adapters import HTTPAdapter
+from requests.exceptions import HTTPError, Timeout
+from requests_oauthlib import OAuth2Session
+
+LOGGER = logging.getLogger(__name__)
+
+AuroraPlusToken: TypeAlias = dict[str, Any]
+
+
+class AuroraPlusAuthenticationError(Exception):
+    pass
+
+
+class AuroraPlusApi:
+    """
+    A client to interact with the Aurora+ API.
+
+    Obtaining a new OAuth token is done in two steps:
+
+        >>> import auroraplus
+        >>> api = auroraplus.AuroraPlusApi()
+        >>> api.oauth_authorize()
+        'https://customers.auroraenergy.com.au/...'
+
+    After following the prompts, the URL of the (error) page that's returned should be passed as the redirect URI.
+
+        >>> token = api.oauth_redirect('https://my.auroraenergy.com.au/login/redirect?state=...')
+
+    The `api` object is now authenticated.
+
+
+    Data can then be fetched with
+
+        >>> api.getcurrent()
+        >>> api.getday()
+        >>> api.getmonth()
+        >>> api.getquarter()
+        >>> api.getyear()
+
+    and inspected in, e.g.,
+
+        >>> api.day
+        {'StartDate': '2023-12-25T13:00:00Z', 'EndDate': '2023-12-26T13:00:00Z', 'TimeMeasureCount': 1, ...
+
+    Power Hour data can be obtained in a similar fashion
+
+        >>> api.getpowerhour()
+        >>> api.powerhour
+        [{'EventName': 'April Flash Event', 'PowerHourEventId': 92, 'StartDateTime': '2026-04-09T08:55:47', 'OfferExpiryDateTime': '2026-04-26T15:55:00', 'TimeslotAccepted': ...
+
+    """
+
+    USER_AGENT: str = "python/auroraplus"
+
+    OAUTH_BASE_URL: str = (
+        "https://customers.auroraenergy.com.au"
+        "/auroracustomers1p.onmicrosoft.com/b2c_1a_sign_in"
+    )
+    AUTHORIZE_URL: str = OAUTH_BASE_URL + "/oauth2/v2.0/authorize"
+    TOKEN_URL: str = OAUTH_BASE_URL + "/oauth2/v2.0/token"
+    CLIENT_ID: str = "2ff9da64-8629-4a92-a4b6-850a3f02053d"
+    REDIRECT_URI: str = "https://my.auroraenergy.com.au/login/redirect"
+
+    API_URL: str = "https://api.auroraenergy.com.au/api"
+    BEARER_TOKEN_URL: str = API_URL + "/identity/LoginToken"
+    BEARER_TOKEN_REFRESH_URL: str = API_URL + "/identity/refreshToken"
+    COOKIE_DOMAIN: str = "api.auroraenergy.com.au"
+
+    SCOPE: ClassVar[list[str]] = ["openid", "profile", "offline_access"]
+
+    session: OAuth2Session
+    token: AuroraPlusToken
+
+    Error: str | None = None
+
+    Active: str = ""
+    customerId: str = ""
+    premiseAddress: str = ""
+    serviceAgreementID: str = ""
+
+    day: dict[str, Any] | None = None
+    week: dict[str, Any] | None = None
+    month: dict[str, Any] | None = None
+    quarter: dict[str, Any] | None = None
+    year: dict[str, Any] | None = None
+
+    powerhour: list[dict] | None = None
+
+    DollarValueUsage: float | None = None
+    KilowattHourUsage: float | None = None
+    AmountOwed: str = ""
+    EstimatedBalance: str = ""
+    AverageDailyUsage: str = ""
+    UsageDaysRemaining: str = ""
+    ActualBalance: str = ""
+    UnbilledAmount: str = ""
+    BillTotalAmount: str = ""
+    NumberOfUnpaidBills: str = ""
+    BillOverDueAmount: str = ""
+
+    CurrentTimeOfUse: str | None = None
+    CurrentTimeOfUsePeriodEndDate: datetime | None = None
+    CurrentTimeOfUseType: str | None = None
+
+    _code_verifier: str = ""
+    _authorization_url: str = ""
+
+    def __init__(
+        self,
+        username: str | None = None,
+        password: str | None = None,
+        *,
+        token: AuroraPlusToken | None = None,
+        id_token: str | None = None,
+        access_token: str | None = None,
+    ):
+        """Initialise the API.
+
+        An authenticated object can be recreated from a preexisting OAuth `token` with
+
+            >>> api = auroraplus.api(token=token)
+
+        A bearer `access_token` can be provided for for one-off queries.
+
+            >>> api = auroraplus.api(access_token=token['access_token'])
+
+        For queries over a longer period of time (>24h), it is possible to pass
+        a recent `id_token`, and let the library handle refreshes.
+
+            >>> api = auroraplus.api(id_token=token['id_token'])
+
+        Backward-compatible ways exists to only pass the `access_token` or `id_token`,
+        as `password` and `username`, respectively>
+
+            >>> api = auroraplus.api(username=token['id_token'])
+            >>> api = auroraplus.api(password=token['access_token'])
+
+        Parameters:
+        -----------
+
+        username: str
+
+            Deprecated, kept for backward compatibility. If passed with an empty
+            `password` and no `token`, the `username` will be used as an `id_token`.
+
+        password: str
+
+            Deprecated, kept for backward compatibility. If passed with an empty
+            `username` and no `token`, the `password` will be used as a bearer
+            `access_token`.
+
+        token : AuroraPlusToken
+
+            A pre-established token. For one-off use, it should contain at least an
+            `access_token` and a `token_type`. For use over 24h, the `RefreshToken`,
+            cookie obtainable by presenting the `id_token` to the `LoginToken` endpoint, should be
+            present as `cookie_RefreshToken`. Any token obtain using the `oauth_*` methods
+            will contain the necessary information.
+
+        access_token : str
+
+            Used for short-lived (<24h) sessions.
+
+        id_token : str
+
+            Used to retrieve an `access_token` and an `cookie_RefreshToken` for
+            longer-lived sessions.
+
+        """
+        self.Error = None
+        backward_compat = False
+        if not token:
+            if password and not username:
+                # Backward compatibility: if no username and no token,
+                # assume the password is a bearer access token
+                LOGGER.warning(
+                    "received deprecated password only, assuming access_token..."
+                )
+                access_token = password
+                backward_compat = True
+            elif username and not password:
+                # Backward compatibility to pass a full token as the first, and only, argument.
+                LOGGER.warning(
+                    "received deprecated username only, assuming id_token..."
+                )
+                id_token = username
+
+        token = token or {}
+
+        if access_token:
+            token["access_token"] = access_token
+            token["token_type"] = "bearer"
+        if id_token:
+            token["id_token"] = id_token
+
+        self.token = token
+        api_adapter = HTTPAdapter(max_retries=2)
+
+        """Create a session and perform all requests in the same session"""
+        session = OAuth2Session(
+            self.CLIENT_ID,
+            redirect_uri=self.REDIRECT_URI,
+            scope=self.SCOPE,
+            token=token,
+        )
+        session.mount(self.API_URL, api_adapter)
+        session.headers.update(
+            {
+                "Accept": "application/json",
+                "User-Agent": self.USER_AGENT,
+                "Accept-Encoding": "gzip, deflate, br",
+                "Connection": "keep-alive",
+            }
+        )
+        self.session = session
+
+        self._update_tokens(token.get("access_token"), token.get("cookie_RefreshToken"))
+
+        if backward_compat and self.token:
+            self.get_info()
+
+    def oauth_authorize(self) -> str:
+        """
+        Start an OAuth Web Application authentication with Aurora Plus
+
+        Returns:
+        --------
+
+        str: the URL to query interactively to authorize this session
+
+        """
+        state = {
+            "id": str(uuid.uuid4()),
+            "meta": {"interactionType": "redirect"},
+        }
+
+        self._code_verifier = "".join(
+            [
+                random.choice(string.ascii_letters + string.digits + "-_")
+                for _ in range(43)
+            ]
+        )
+        code_challenge = base64.urlsafe_b64encode(
+            hashlib.sha256(self._code_verifier.encode()).digest()
+        ).strip(b"=")
+
+        self._authorization_url, _ = self.session.authorization_url(
+            self.AUTHORIZE_URL,
+            client_request_id=uuid.uuid4(),
+            client_info=1,
+            code_challenge=code_challenge,
+            code_challenge_method="S256",
+            state=base64.encodebytes(json.dumps(state).encode()),
+        )
+
+        return self._authorization_url
+
+    def oauth_redirect(self, authorization_response: str):
+        """
+        Continue an OAuth Web Application authentication with Aurora Plus.
+
+        Needs to be called after oauth_authorize.
+
+        Parameters:
+        -----------
+
+        authorization_response: str
+
+            The full URI of the response (error) page after authentication.
+
+        Returns:
+        --------
+
+        dict: full token information
+
+        """
+        if not self.session.compliance_hook["access_token_response"]:
+            self.session.register_compliance_hook(
+                "access_token_response", self._include_access_token
+            )
+
+        return self.session.fetch_token(
+            self.TOKEN_URL,
+            authorization_response=authorization_response,
+            code_verifier=self._code_verifier,
+        )
+
+    def oauth_dump(self) -> dict[str, str]:
+        """
+        Export partial OAuth state, for use in asynchronous or request/response-based
+        workflows.
+
+        Returns:
+        --------
+
+        dict: a dict of all the relevant state
+        """
+        return {
+            "authorization_url": self._authorization_url,
+            "code_verifier": self._code_verifier,
+        }
+
+    def oauth_load(
+        self,
+        authorization_url: str,
+        code_verifier: str,
+    ):
+        """
+        Import partial OAuth state.
+
+        Params:
+        -------
+
+        kwargs: pass the state dict returned from oauth_dump.
+        """
+        self._authorization_url = authorization_url
+        self._code_verifier = code_verifier
+
+    def _include_access_token(self, r: Response) -> Response:
+        """
+        OAuth compliance hook to fetch the bespoke LoginToken,
+        and present it as a standard access_token, as well as the value of the
+        RefreshToken cookie, for later requests to BEARER_TOKEN_REFRESH_URL.
+
+        Returns:
+        --------
+
+        Response: the original respones, with the full token, and additional
+        cookie_RefreshToken attribute, if available..
+
+        Response
+        """
+        rjs: dict[str, Any] = r.json()
+        id_token: str | None = rjs.get("id_token")
+
+        access_token, refresh_token_cookie = self._get_access_token(id_token)
+
+        rjs.update(
+            {
+                "access_token": access_token,
+                "cookie_RefreshToken": refresh_token_cookie,
+                "scope": "openid profile offline_access",
+            }
+        )
+
+        r._content = json.dumps(rjs).encode()
+
+        return r
+
+    def gettoken(self, *args, **kwargs):
+        """
+        Deprecated, kept for backward compatibility
+
+        args and kwargs are to catch obsolete arguments.
+        """
+        self.get_info()
+
+    def get_info(self):
+        """Get CustomerID and ServiceAgreementID"""
+        data = self.request("/customers/current")
+        if not data:
+            return
+        current: dict[str, Any] = data[0]
+        self.customerId = current["CustomerID"]
+
+        """Loop through premises to get active """
+        premises: dict[str, Any] = current["Premises"]
+        for premise in premises:
+            if premise["ServiceAgreementStatus"] == "Active":
+                self.Active = premise["ServiceAgreementStatus"]
+                self.serviceAgreementID = premise["ServiceAgreementID"]
+                self.premiseAddress = premise["Address"]
+        if self.Active != "Active":
+            self.Error = "No active premise found"
+
+    def request_usage(self, period: str, index: int = -1) -> dict[str, Any] | None:
+        if not hasattr(self, "serviceAgreementID") or not self.serviceAgreementID:
+            self.get_info()
+        try:
+            resp = self._fetch(
+                self.API_URL
+                + "/usage/"
+                + period
+                + "?serviceAgreementID="
+                + self.serviceAgreementID
+                + "&customerId="
+                + self.customerId
+                + "&index="
+                + str(index)
+            )
+            if resp.status_code == 200:
+                return resp.json()
+            else:
+                self.Error = f"Usage data request for {period} failed: " + resp.reason
+        except Timeout:
+            self.Error = f"Usage data request for {period} timed out"
+
+    def getsummary(self, index: int = -1):
+        summarydata = self.request_usage("day", index)
+        self.DollarValueUsage = summarydata["SummaryTotals"]["DollarValueUsage"]
+        self.KilowattHourUsage = summarydata["SummaryTotals"]["KilowattHourUsage"]
+
+    def getday(self, index: int = -1):
+        self.day = self.request_usage("day", index)
+
+    def getweek(self, index: int = -1):
+        self.week = self.request_usage("week", index)
+
+    def getmonth(self, index: int = -1):
+        self.month = self.request_usage("month", index)
+
+    def getquarter(self, index: int = -1):
+        self.quarter = self.request_usage("quarter", index)
+
+    def getyear(self, index: int = -1):
+        self.year = self.request_usage("year", index)
+
+    def getcurrent(self):
+        """Request current customer data"""
+        data = self.request("/customers/current")
+        if not data:
+            return
+
+        current: dict[str, Any] = data[0]
+
+        """Loop through premises to match serviceAgreementID already found in token request"""
+        premises: dict[str, Any] = current["Premises"]
+        found = ""
+        for premise in premises:
+            if premise["ServiceAgreementID"] == self.serviceAgreementID:
+                found = "true"
+                self.AmountOwed = "{:.2f}".format(premise["AmountOwed"])
+                self.EstimatedBalance = "{:.2f}".format(premise["EstimatedBalance"])
+                self.AverageDailyUsage = "{:.2f}".format(premise["AverageDailyUsage"])
+                self.UsageDaysRemaining = premise["UsageDaysRemaining"]
+                self.ActualBalance = "{:.2f}".format(premise["ActualBalance"])
+                self.UnbilledAmount = "{:.2f}".format(premise["UnbilledAmount"])
+                self.BillTotalAmount = "{:.2f}".format(premise["BillTotalAmount"])
+                self.NumberOfUnpaidBills = premise["NumberOfUnpaidBills"]
+                self.BillOverDueAmount = "{:.2f}".format(premise["BillOverDueAmount"])
+
+                try:
+                    self.CurrentTimeOfUse = premise["CurrentTimeOfUse"]
+                    self.CurrentTimeOfUsePeriodEndDate = premise[
+                        "CurrentTimeOfUsePeriodEndDate"
+                    ]
+                    self.CurrentTimeOfUseType = premise["CurrentTimeOfUseType"]
+                except (KeyError, ValueError):
+                    pass
+
+        if found != "true":
+            self.Error = "ServiceAgreementID not found"
+
+    def getpowerhour(self):
+        self.powerhour = self.request("/powerhour/upcoming-active")
+
+    def request(self, url: str) -> dict[str, Any] | list | None:
+        try:
+            resp = self._fetch(self.API_URL + url)
+            if resp.status_code == 200:
+                return resp.json()
+            else:
+                self.Error = f"Data request for {url} failed: " + resp.reason
+        except Timeout:
+            self.Error = f"Data request for {url} timed out"
+
+    def _fetch(self, url: str) -> Response:
+        if not self.token.get("access_token"):
+            LOGGER.debug("access_token missing, obtaining...")
+
+            if id_token := self.token.get("id_token"):
+                try:
+                    access_token, refresh_token_cookie = self._get_access_token(
+                        id_token
+                    )
+                except (HTTPError, AuroraPlusAuthenticationError) as exc:
+                    # We'll continue, fail, and hopefully get a chance to use the
+                    # RefreshToken cookie.
+                    LOGGER.warning(f"can't obtain access_token: {exc}")
+                else:
+                    self._update_tokens(access_token, refresh_token_cookie)
+
+        r = self.session.get(url)
+
+        if r.status_code in [401, 403]:
+            LOGGER.info("access_token refused, refreshing...")
+
+            if not (refresh_token := self.token.get("cookie_RefreshToken")):
+                raise AuroraPlusAuthenticationError(
+                    "can't refresh access_token: RefreshToken cookie unknown"
+                )
+
+            try:
+                access_token, refresh_token_cookie = self._refresh_access_token(
+                    refresh_token
+                )
+            except (HTTPError, AuroraPlusAuthenticationError) as exc:
+                # We'll continue, fail, and hopefully get a chance to use the
+                # RefreshToken cookie.
+                LOGGER.warning(f"can't obtain RefreshToken cookie: {exc}")
+            else:
+                self._update_tokens(access_token, refresh_token_cookie)
+
+            r = self.session.get(url)
+
+        r.raise_for_status()
+
+        return r
+
+    def _get_access_token(self, id_token: str) -> tuple[str, str | None]:
+        LOGGER.debug(f"retrieving access_token with {id_token=}...")
+
+        # Incorrect, but looks the part for validation.
+        self.session.token["access_token"] = id_token
+
+        atr = self.session.post(
+            self.BEARER_TOKEN_URL, json={"remember": "True", "token": id_token}
+        )
+        atr.raise_for_status()
+
+        return self._extract_access_refresh_token(atr)
+
+    def _refresh_access_token(self, refresh_token: str) -> tuple[str, str | None]:
+        LOGGER.debug(f"refreshing access_token with cookie {refresh_token=}...")
+
+        rtr = self.session.post(self.BEARER_TOKEN_REFRESH_URL, json={})
+        rtr.raise_for_status()
+
+        return self._extract_access_refresh_token(rtr)
+
+    def _extract_access_refresh_token(
+        self, response: Response
+    ) -> tuple[str, str | None]:
+        refresh_token_cookie = response.cookies.get("RefreshToken")
+        if not refresh_token_cookie:
+            LOGGER.warning(
+                f"Missing RefreshToken cookie in {self.BEARER_TOKEN_URL} response; did you check `Keep me logged in` on the aurora+ login page?"
+            )
+
+        access_token: str = response.json().get("accessToken").split()[1]
+        if not access_token:
+            raise AuroraPlusAuthenticationError(
+                f"Missing access_token in {self.BEARER_TOKEN_URL} response"
+            )
+
+        return access_token, refresh_token_cookie
+
+    def _update_tokens(
+        self, access_token: str | None, refresh_token_cookie: str | None
+    ):
+        if not access_token and not refresh_token_cookie:
+            LOGGER.warning(
+                "neither access_token nor RefreshToken cookie known; "
+                + "skipping session tokens update"
+            )
+            return
+
+        new_token = {}
+        if access_token:
+            LOGGER.debug(f"updating token in session: {access_token=}")
+            self.session.access_token = access_token
+            new_token.update(
+                {
+                    "access_token": access_token,
+                    "token_type": "bearer",
+                }
+            )
+        if refresh_token_cookie:
+            LOGGER.debug(f"updating RefreshToken in session: {refresh_token_cookie=}")
+            self.session.cookies.set(
+                "RefreshToken", refresh_token_cookie, domain=self.COOKIE_DOMAIN
+            )
+            new_token.update(
+                {
+                    "cookie_RefreshToken": refresh_token_cookie,
+                }
+            )
+        self.token.update(new_token)
+        self.session.token = self.token
+
+
+@deprecated(
+    "Use of auroraplus.api is deprecated, please use auroraplus.AuroraPlusApi instead"
+)
+class api(AuroraPlusApi):
+    """Backward compatibility adapter."""
+
+    def __init__(self, *args, **kwargs):
+        LOGGER.warning(
+            "Use of auroraplus.api is deprecated, please use auroraplus.AuroraPlusApi instead"
+        )
+        super().__init__(*args, **kwargs)

auroraplus/get_token.py

@@ -0,0 +1,40 @@
+#!/bin/env python
+
+import json
+from textwrap import dedent
+
+from .api import AuroraPlusApi
+
+
+def get_token():
+    api = AuroraPlusApi()
+    url = api.oauth_authorize()
+
+    print(
+        dedent("""
+        Please visit the following URL in a browser, and follow the login prompts ...
+
+        Make sure to check `Keep me logged in` to obtain a long-lived refresh token.
+        """)
+    )
+    print(url)
+
+    print("\nThis will redirect to an error page (Cradle Mountain).\n")
+
+    redirect_uri = input("Please enter the full URL of the error page: ")
+
+    token = api.oauth_redirect(redirect_uri)
+
+    print("\nThe new token is\n")
+    print(json.dumps(token))
+
+    print("\nThe access token (to use as a bearer token for one-off requests) is\n")
+    print(json.dumps(token["access_token"]))
+
+    print()
+
+    return token
+
+
+if __name__ == "__main__":
+    get_token()

auroraplus/repl.py

@@ -0,0 +1,47 @@
+#!/bin/env python
+
+import code
+import json
+import logging
+import os
+import sys
+
+from .api import AuroraPlusApi
+from .get_token import get_token
+
+log_level = logging.DEBUG
+logger = logging.getLogger(__name__)
+
+AURORAPLUS_TOKEN = "AURORAPLUS_TOKEN"
+
+
+def repl():
+    logging.basicConfig(level=log_level)
+
+    token = None
+    if token_json := os.getenv(AURORAPLUS_TOKEN):
+        try:
+            token = json.loads(token_json)
+        except json.JSONDecodeError:
+            logger.warning(f"{AURORAPLUS_TOKEN} is not valid JSON")
+
+    if not token:
+        logger.info(
+            f"{AURORAPLUS_TOKEN} environment variable is empty, requesting interactively ..."
+        )
+        token = get_token()
+
+    try:
+        api = AuroraPlusApi(token=token)
+        api.get_info()
+    except Exception as exc:
+        logger.exception("exception when setting up", exc_info=exc)
+    sys.ps1 = "AuroraPlus >>> "
+    code.interact(
+        local=locals(),
+        banner="\nInitialised AuroraPlus API object available as `api`.\n",
+    )
+
+
+if __name__ == "__main__":
+    repl()

auroraplus-1.7.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: auroraplus
+Version: 1.7.0
+Summary: Python library to access the Aurora+ API: https://api.auroraenergy.com.au/api
+Author-email: Leigh Curran <AuroraPlusPy@outlook.com>
+License-Expression: MIT
+Keywords: Aurora+,AuroraPlus,Aurora,Tasmania,API
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: brotli
+Requires-Dist: requests
+Requires-Dist: requests_oauthlib
+Provides-Extra: build
+Requires-Dist: build<0.10.0; extra == "build"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-ruff; extra == "test"
+Requires-Dist: requests-mock; extra == "test"
+Dynamic: license-file
+
+[![buy me a coffee](https://img.shields.io/badge/If%20you%20like%20it-Buy%20us%20a%20coffee-green.svg?style=for-the-badge)](https://www.buymeacoffee.com/leighcurran)
+
+AuroraPlus is a package to pull data from https://api.auroraenergy.com.au/api. To use the Aurora+ API you need a valid account with Aurora.
+
+## Requirements
+- Install Python 3.9 (for all users)
+- `pip install .`
+
+## Usage
+
+### Obtain a token
+
+The easieast way to obtain a new token is to use the `auroraplus_get_token`
+script.
+
+To do this more programatically, obtaining a token is an interactive process
+where the user needs to log on to the AuroraPlus web application.
+
+    >>> import auroraplus
+    >>> api = auroraplus.AuroraPlusApi()
+    >>> api.oauth_authorize()
+    'https://customers.auroraenergy.com.au/auroracustomers1p.onmicrosoft.com/b2c_1a_sign_in//oauth2/v2.0/authorize?response_type=code&client_id=2ff9da64-8629-4a92-a4b6-850a3f02053d&redirect_uri=https%3A%2F%2Fmy.auroraenergy.coom.au%2Flogin%2Fredirect&scope=openid+profile+offline_access&state=...&client_info=1'
+
+Follow the URL above in a browser to authenticate with username+password and
+MFA. This will redirect to an error page (Cradle Mountain). Copy the full URL,
+of the error page and continue.
+
+    >>> api.oauth_redirect('https://my.auroraenergy.com.au/login/redirect?state=...')
+    {'id_token': 'ey...', 'access_token': 'ey...', 'token_type': 'bearer', ...}
+
+The `api` object is now ready to use (start with `api.get_info()`. The token
+returned in the last step can be saved for later use when re-initialising the
+`api` object without having to follow the OAuth flow to obtain a new
+authorisation.
+
+### Connect to Aurora+ API with a pre-issued token
+
+    import auroraplus
+    api = auroraplus.AuroraPlusApi(token={"access_token": "...", "token_type": "bearer"})
+    api.get_info()
+
+For backward compatibility with users of the login/password method, the
+`access_token` can be passed as the `password` if the `user` is empty.
+
+    import auroraplus
+    api = auroraplus.AuroraPlusApi(password=<ACCESS_TOKEN>)
+    api.get_info()
+
+### Get current account information
+
+    api.getcurrent()
+
+getcurrent() gets the following data:
+
+    EstimatedBalance - This is shown in the Aurora+ app as 'Balance'
+    UsageDaysRemaining - This is shown in the Aurora+ app as 'Days Prepaid'
+    AverageDailyUsage
+    AmountOwed
+    ActualBalance
+    UnbilledAmount
+    BillTotalAmount
+    NumberOfUnpaidBills
+    BillOverDueAmount
+    
+    Note: All data except EstimatedBalance is updated Daily.
+
+    If relevant, time-of-use tariffs can be found in the following attributes:
+
+    CurrentTimeOfUse
+    CurrentTimeOfUsePeriodEndDate
+    CurrentTimeOfUseType
+
+An example getting specific data with getcurrent:
+
+    import auroraplus
+    api = auroraplus.AuroraPlusApi(token={"access_token": "...", "token_type": "bearer"})
+    api.get_info()
+    if (not api.Error):
+        api.getcurrent()
+        print(api.AmountOwed)
+    else:
+        print(api.Error)
+        
+### Get summary usage information
+
+    api.getsummary()
+    
+    Note: This returns two collections, DollarValueUsage and KilowattHourUsage.
+    
+An example getting specific data with getsummary:
+
+    import auroraplus
+    api = auroraplus.AuroraPlusApi(token={"access_token": "...", "token_type": "bearer"})
+    api.get_info()
+    if (not api.Error):
+        api.getsummary()
+        print(api.DollarValueUsage['T41'])
+        print(api.DollarValueUsage['T31'])
+        print(api.DollarValueUsage['Other'])
+        print(api.DollarValueUsage['Total'])
+        print(api.KilowattHourUsage['T41'])
+        print(api.KilowattHourUsage['T31'])
+        print(api.KilowattHourUsage['Total'])
+    else:
+        print(api.Error)
+        
+    Note: Offpeak tarrifs not listed
+
+### Get usage data
+
+The following returns all available data in json format for each timespan:
+
+    api.getday()
+    api.getweek()
+    api.getmonth()
+    api.getquarter()
+    api.getyear()
+
+Full example:
+
+    api = auroraplus.AuroraPlusApi(token={"access_token": "...", "token_type": "bearer"})
+    api.get_info()
+    if (not api.Error):
+        api.getcurrent()
+        print(api.AmountOwed)
+        
+        api.getday()
+        print(api.day)
+        
+        api.getweek()
+        print(api.week)
+        
+        api.getmonth()
+        print(api.month
+        
+        api.getyear()
+        print(api.year)
+    else:
+        print(api.Error)
+
+### Get Power Hour
+
+Information about upcoming Power Hour can be obtained with the `getpowerhour` method. It ppopulates a `powerhour` attribute. 
+
+    import json
+    api = auroraplus.AuroraPlusApi(token={"access_token": "...", "token_type": "bearer"})
+    api.getcurrent()
+    api.getpowerhour()
+    print(json.dumps(api.powerhour, indent=2))
+    [
+      {
+        "EventName": "Grand Final Weekend",
+        "PowerHourEventId": 114,
+        "StartDateTime": "2026-08-25T09:32:42",
+        "OfferExpiryDateTime": "2026-09-27T12:55:00",
+        "TimeslotAccepted": {
+          "PowerHourTimeSlotId": 906,
+          "StartDateTime": "2026-09-25T13:00:00",
+          "EndDateTime": "2026-09-25T17:00:00",
+          "ExpiryDateTime": "2026-09-25T12:55:00"
+        },
+        "TimeslotAll": [
+          {
+            "PowerHourTimeSlotId": 901,
+            "StartDateTime": "2026-09-24T11:00:00",
+            "EndDateTime": "2026-09-24T15:00:00",
+            "ExpiryDateTime": "2026-09-24T10:55:00"
+          },
+    ...
+
+## Development
+
+### Tests
+
+Currently, tests only do a lint check.
+
+    pip install -e .[test]
+    pytest
+
+Some errors can be fixed automatically with
+
+    ruff check --fix

auroraplus-1.7.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+auroraplus/__init__.py,sha256=v74jI5kX4o5aV3n-cBQPCdu4Onzv5HQTkbrHSHuHITE,276
+auroraplus/api.py,sha256=JF30BSmQJap6EmOnaErRHVfoolKedThvmjMRnCL4FWQ,20524
+auroraplus/get_token.py,sha256=FqQ1PHD-nJB4H_tt5nJUZptwK3UZANZkK-s7bHh1IB8,870
+auroraplus/repl.py,sha256=OKThVbX9-VmFb1Ej5JqGNOp4Qg4GDi1VHNbnnNRFq1s,1071
+auroraplus-1.7.0.dist-info/licenses/LICENSE.txt,sha256=qiJqOuL6ktuNDwGBADXIdEDssTFY4Xgl89oT6Nn4Cys,1064
+auroraplus-1.7.0.dist-info/METADATA,sha256=C0zb_nYl0YvAmOVfvxl4aYgThNYFiTI4bMZRUY41THk,6822
+auroraplus-1.7.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+auroraplus-1.7.0.dist-info/entry_points.txt,sha256=bAepK_dEkLQdaH-yrmpqCskWKTNJvLos_IgPgyWO1TE,101
+auroraplus-1.7.0.dist-info/top_level.txt,sha256=0NUDFhgyvYFE_Ol0WpknG9O8SbTFyKEq1fEQO8scxdw,11
+auroraplus-1.7.0.dist-info/RECORD,,

auroraplus-1.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

auroraplus-1.7.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+auroraplus_get_token = auroraplus:get_token
+auroraplus_repl = auroraplus.repl:repl

auroraplus-1.7.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,17 @@
+MIT License
+Copyright (c) 2021 Leigh Curran
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

auroraplus-1.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+auroraplus