ekzexport 0.1.0__py3-none-any.whl

ekzexport/apitypes.py

@@ -0,0 +1,120 @@
+from typing import TypedDict, List, Optional
+
+
+class Address(TypedDict):
+    addressNumber: str
+    street: str
+    houseNumber: str
+    houseNumberDetails: str
+    locationDetails: str
+    floor: str
+    postalCode: str
+    city: str
+
+
+class ISDContract(TypedDict):
+    """Used for the contracts property in InstallationSelectionData."""
+    gpart: str
+    vkonto: str
+    vertrag: str
+    anlage: str
+    vstelle: str
+    haus: str
+    einzdat: str
+    auszdat: Optional[str]
+    sparte: str
+
+
+class ISDAnlage(TypedDict):
+    """Used for the eanl property in InstallationSelectionData."""
+    anlage: str
+    sparte: str
+    vstelle: str
+    anlart: str
+    spebene: str
+    zzenergietraeger: Optional[str]
+    zzevgstat: Optional[str]
+    zzevganlage: Optional[str]
+    eanlhTariftyp: str
+    eanlhAbleinh: str
+
+
+class ISDStelle(TypedDict):
+    vstelle: str
+    haus: str
+    eigent: str
+    vbsart: str
+    lgzusatz: str
+    floor: str
+    zzlage: str
+    zzlgzusatz: str
+    iflotZzanobjart: str
+    iflotZzeigen: str
+    iflotZzegid: str
+    address: Address
+
+
+class ISDFkkVkp(TypedDict):
+    vkont: str
+    gpart: str
+    opbuk: str
+    stdbk: str
+    abrwe: Optional[str]
+    abwra: Optional[str]
+    abwma: Optional[str]
+    ebvty: Optional[str]
+    abvty: str
+    ezawe: str
+    azawe: str
+    vkpbz: str
+    ktokl: str
+    consolidatorId: str
+    zzRechDet: str
+
+
+class InstallationSelectionData(TypedDict):
+    """Return schema for /consumption-view/v1/installation-selection-data?installationVariant=CONSUMPTION"""
+    contracts: List[ISDContract]
+    eanl: List[ISDAnlage]
+    evbs: List[ISDStelle]
+    fkkvkp: List[ISDFkkVkp]
+    commonData: Optional[str]
+
+
+class IDProperty(TypedDict):
+    property: str
+    ab: str
+    bis: str
+
+
+class InstallationData(TypedDict):
+    """Return schema for /consumption-view/v1/installation-data?installationId=..."""
+    status: List[IDProperty]
+
+
+class Value(TypedDict):
+    value: float
+    timestamp: int
+    date: str
+    time: str
+    status: str
+
+
+class Series(TypedDict):
+    level: str
+    energyType: Optional[str]
+    sourceType: Optional[str]
+    tariffType: str
+    ab: str
+    bis: str
+    values: List[Value]
+
+
+class ConsumptionData(TypedDict):
+    """Return schema for /consumption-view/v1/consumption-data?installationId=..."""
+    series: Optional[Series]
+    seriesHt: Optional[Series]
+    seriesNetz: Optional[Series]
+    seriesNetzHt: Optional[Series]
+    seriesNetzHt: Optional[Series]
+    seriesNt: Optional[Series]

ekzexport/cli.py

@@ -0,0 +1,167 @@
+import itertools
+import json
+import os
+import os.path
+import traceback
+
+import click
+
+from platformdirs import user_config_dir, site_config_dir
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from .session import Session
+from .timeutil import format_api_date
+from .util import Installation, pass_installation, pass_session, DataSelection, pass_data
+from .exporters import ALL_EXPORT_COMMANDS
+
+
+@click.group()
+@click.option('--user', default=None, help='Username')
+@click.option('--password', default=None, help='Password')
+@click.pass_context
+def cli(ctx: click.Context, user: str, password: str):
+    """EKZ API client.
+
+    The client only supports user/password login; 3rd party login providers are not supported.
+    All dates are expected to be in Y-m-d notation, e.g. 2000-06-30."""
+    locations = [os.curdir, os.path.expanduser('~'),
+                 user_config_dir('ekzexport', roaming=True), site_config_dir('ekzexport')]
+
+    if user is None or password is None:
+        for location in locations:
+            try:
+                with open(os.path.join(location, 'ekzexport.json'), 'r') as f:
+                    config = json.load(f)
+                    user = config['user']
+                    password = config['password']
+                    break
+            except Exception as e:
+                pass
+
+    if user is None or password is None:
+        click.echo('Unable to determine username and password. Either use the --user and --password options '
+                   'or place them in a JSON file at one of these locations:', err=True)
+        for location in locations:
+            click.echo('  ' + os.path.join(location, 'ekzexport.json'), err=True)
+        raise click.UsageError('Missing username or password')
+
+    ctx.obj = ctx.with_resource(Session(user, password))
+
+
+@cli.command()
+@pass_session
+def overview(session: Session):
+    """Get an overview over available contracts."""
+    contracts = Table(title='Contracts', box=box.MINIMAL_HEAVY_HEAD)
+    contracts.add_column('Installation ID')
+    contracts.add_column('Address')
+    contracts.add_column('Move-in Date')
+    contracts.add_column('Move-out Date')
+
+    for c in session.installation_selection_data['contracts']:
+        address = 'N/A'
+        for s in session.installation_selection_data['evbs']:
+            if s['vstelle'] == c['vstelle']:
+                address = (f"{s['address']['street']} {s['address']['houseNumber']}, "
+                           f"{s['address']['postalCode']} {s['address']['city']}")
+                break
+        contracts.add_row(c['anlage'], address, c['einzdat'], c['auszdat'])
+
+    console = Console()
+    console.print(contracts)
+
+
+@cli.group('installation')
+@click.argument('installation_id')
+@click.pass_context
+def installation_group(ctx: click.Context, installation_id: str):
+    """Installation-specific actions."""
+    ctx.obj = Installation(installation_id)
+
+
+@installation_group.command('properties')
+@pass_installation
+@pass_session
+def installation_properties(session: Session, installation: Installation):
+    """List installation properties."""
+    table = Table(title='Properties', box=box.MINIMAL_HEAVY_HEAD)
+    table.add_column('Property')
+    table.add_column('From')
+    table.add_column('Until')
+
+    for p in session.get_installation_data(installation.id)['status']:
+        table.add_row(p['property'], p['ab'], p['bis'])
+
+    console = Console()
+    console.print(table)
+
+
+@installation_group.group('data')
+@click.option('--type', 'data_type', default=None, metavar='TYPE',
+              help='Type of consumption data to fetch. '
+                   'Defaults to PK_VERB_15MIN if available, PK_VERB_TAG_EDM otherwise.')
+@click.option('--from', 'date_from', default=None, metavar='YYYY-MM-DD',
+              help='Date from which to start fetching data. Defaults to 7 days before to.')
+@click.option('--to', 'date_to', default=None, metavar='YYYY-MM-DD',
+              help='Date until which to fetch data. Defaults to the latest date with data available.')
+@click.option('-l', '--limit', type=int, default=4, help='Maximum number of weeks to download.')
+@pass_installation
+@pass_session
+@click.pass_context
+def installation_data(ctx: click.Context, session: Session, installation: Installation,
+                      data_type: str | None, date_from: str | None, date_to: str | None, limit: int):
+    """Data retrieval actions.
+
+    You can control the time window of data to be downloaded with the --from and --to options. If they are not
+    explicitly specified, the bounds of available data reported by the API will be used. The number of weeks
+    worth of data is limited to prevent unintended large downloads. Use --limit to override."""
+    ctx.obj = DataSelection(session, installation.id, data_type, date_from, date_to, limit)
+
+
+@installation_data.command('show')
+@pass_data
+@pass_installation
+@pass_session
+def show_installation_data(session: Session, installation: Installation, data: DataSelection):
+    """Show consumption data."""
+    table = Table(title='Consumption Data', box=box.MINIMAL_HEAVY_HEAD)
+    table.add_column('Time')
+    table.add_column('kWh')
+    table.add_column('Tariff')
+    table.add_column('Status')
+
+    weekly_data = []
+    for week in data.requested_weeks():
+        d = session.get_consumption_data(installation.id, data.data_type,
+                                         format_api_date(week.start), format_api_date(week.end))
+        weekly_data.append((dict(x, tariff='NT') for x in d['seriesNt']['values']))
+        weekly_data.append((dict(x, tariff='HT') for x in d['seriesHt']['values']))
+
+    values = sorted(itertools.chain(*weekly_data), key=lambda x: x['timestamp'])
+    for v in values:
+        table.add_row(f'{v["date"]} {v["time"]}', str(v['value']), v['tariff'], v['status'])
+
+    console = Console()
+    console.print(table)
+
+
+@installation_data.group('export')
+def export_group():
+    """Export consumption data."""
+    pass
+
+
+for cmd in ALL_EXPORT_COMMANDS:
+    export_group.add_command(cmd)
+
+
+def main():
+    try:
+        cli()
+    except Exception as e:
+        click.echo(click.style('An unexpected error occurred during execution:', fg='red'), err=True)
+        for line in traceback.format_exception(e):
+            click.echo('  ' + line, err=True)
+        return 1

ekzexport/session.py

@@ -0,0 +1,80 @@
+from functools import cached_property
+
+import requests
+from bs4 import BeautifulSoup
+
+from .apitypes import *
+
+HTML_HEADERS = {
+    'Accept': 'text/html,application/xhtml+xml,application/xml'
+}
+JSON_HEADERS = {
+    'Accept': 'application/json, text/plain, */*'
+}
+
+
+class Session:
+    """Represents a session with the EKZ API."""
+    def __init__(self, username: str, password: str, login_immediately=False):
+        self._session = requests.Session()
+        self._session.headers.update({'User-Agent': 'ekzexport'})
+        self._username = username
+        self._password = password
+        self._login_immediately = login_immediately
+        self._logged_in = False
+
+    def __enter__(self):
+        if self._login_immediately:
+            self._ensure_logged_in()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._logged_in:
+            r = self._session.post('https://my.ekz.ch/logout', headers=HTML_HEADERS,
+                                   data={'_csrf': self.get_csrf_token()})
+            r.raise_for_status()
+
+    def _ensure_logged_in(self):
+        if self._logged_in:
+            return
+        r = self._session.get('https://my.ekz.ch/verbrauch/', headers=HTML_HEADERS)
+        r.raise_for_status()
+
+        # Find the login form and get the action URL, so we can submit credentials.
+        soup = BeautifulSoup(r.text, 'html.parser')
+        loginform = soup.select('form[id=kc-form-login]')
+        authurl = loginform[0]['action']
+
+        r = self._session.post(authurl, data={'username': self._username, 'password': self._password})
+        r.raise_for_status()
+        self._logged_in = True
+
+    def get_csrf_token(self):
+        self._ensure_logged_in()
+        r = self._session.get('https://my.ekz.ch/api/portal-services/csrf/v1/token', headers=JSON_HEADERS)
+        r.raise_for_status()
+        return r.json()['token']
+
+    @cached_property
+    def installation_selection_data(self) -> InstallationSelectionData:
+        self._ensure_logged_in()
+        r = self._session.get('https://my.ekz.ch/api/portal-services/consumption-view/v1/installation-selection-data'
+                              '?installationVariant=CONSUMPTION', headers=JSON_HEADERS)
+        r.raise_for_status()
+        return r.json()
+
+    def get_installation_data(self, installation_id: str) -> InstallationData:
+        self._ensure_logged_in()
+        r = self._session.get('https://my.ekz.ch/api/portal-services/consumption-view/v1/installation-data'
+                              '?installationId=' + installation_id, headers=JSON_HEADERS)
+        r.raise_for_status()
+        return r.json()
+
+    def get_consumption_data(self, installation_id: str, data_type: str,
+                             date_from: str, date_to: str) -> ConsumptionData:
+        self._ensure_logged_in()
+        r = self._session.get(f'https://my.ekz.ch/api/portal-services/consumption-view/v1/consumption-data'
+                              f'?installationId={installation_id}&from={date_from}&to={date_to}&type={data_type}',
+                              headers=JSON_HEADERS)
+        r.raise_for_status()
+        return r.json()

ekzexport/timeutil.py

@@ -0,0 +1,68 @@
+import datetime
+
+from typing import Iterable, Callable, TypeVar
+from zoneinfo import ZoneInfo
+
+ZRH_TZ = ZoneInfo(key='Europe/Zurich')
+UTC_TZ = ZoneInfo(key='UTC')
+Input = TypeVar('Input')
+Output = TypeVar('Output')
+
+
+def parse_zrh_day(day: str) -> datetime.date:
+    """Convert a day string into a date.
+
+    Accepts both ISO-style YYYY-MM-DD and Swiss-style DD.MM.YYYY formats."""
+    if '.' in day:
+        return datetime.datetime.strptime(day, '%d.%m.%Y').replace(tzinfo=ZRH_TZ).date()
+    return datetime.datetime.strptime(day, '%Y-%m-%d').replace(tzinfo=ZRH_TZ).date()
+
+
+def parse_zrh_datetime(dt: str) -> datetime.datetime:
+    """Convert Swiss-style DD.MM.YYYY HH:MM to datetime."""
+    return datetime.datetime.strptime(dt, '%d.%m.%Y %H:%M').replace(tzinfo=ZRH_TZ)
+
+
+def format_api_date(dt: datetime.date) -> str:
+    """Format date as YYYY-MM-DD, i.e. what the API expects."""
+    return dt.strftime("%Y-%m-%d")
+
+
+def parse_api_timestamp(timestamp: int) -> datetime.datetime:
+    """Parse UTC timestamp from API."""
+    return datetime.datetime.strptime(str(timestamp), '%Y%m%d%H%M%S')
+
+
+def convert_zrh_datetime_sequence(input: Iterable[Input], key: Callable[[Input], str],
+                                  output: Callable[[datetime.datetime, Input], Output]):
+    """Given a some sequence, parse ZRH datetimes in DST-aware fashion and generate an output.
+
+    Since the API uses dates at times in Zurich local time, during the transition to winter time, an hour
+    repeats. When handling such sequences, we thus need to be aware whether we're in the first or second run
+    through the hour.
+
+    This is achieved by setting fold=1 on the resulting datetime objects - beware however that comparisons and
+    equality or not trivial (see PEP 495). It's better to convert to UNIX timestamps or UTC datetimes when doing so.
+
+    :param input: Arbitrary iterable
+    :param key: Callable that returns the datetime string for an item
+    :param output: Callable f(datetime.datetime, item) returning an item of the result
+    :returns: A generator with the output function applied to each item in the input
+    """
+    prev_dt = datetime.datetime(1970, 1, 1, tzinfo=UTC_TZ)
+    in_fold = False
+    for item in input:
+        ts = key(item)
+        dt = parse_zrh_datetime(ts)
+
+        if in_fold:
+            if dt.replace(fold=1).timestamp() != dt.timestamp():
+                dt = dt.replace(fold=1)  # Still in fold
+            else:
+                in_fold = False
+        elif dt < prev_dt and dt.replace(fold=1).timestamp() != dt.timestamp():
+            dt = dt.replace(fold=1)
+            in_fold = True
+
+        prev_dt = dt
+        yield output(dt, item)

ekzexport/util.py

@@ -0,0 +1,275 @@
+import itertools
+
+import click
+import datetime
+
+from functools import cached_property
+from typing import Optional, List, Dict, Iterable
+
+from .session import Session
+from .apitypes import IDProperty
+from .timeutil import parse_zrh_day, format_api_date
+
+
+class DayRange:
+    """A range of days, including both start and end dates."""
+    def __init__(self, start: datetime.date, end: datetime.date):
+        assert isinstance(start, datetime.date)
+        assert isinstance(end, datetime.date)
+        self.start = start
+        self.end = end
+
+    def append_consecutive(self, day: datetime.date) -> bool:
+        """If the day is consecutive or already included, extend the range if needed. Otherwise, return False."""
+        if self.start <= day <= self.end:
+            return True
+        if self.end + datetime.timedelta(days=1) == day:
+            self.end = day
+            return True
+        return False
+
+    def __eq__(self, other):
+        return self.start == other.start and self.end == other.end
+
+    def __repr__(self):
+        return f"DayRange({repr(self.start)}, {repr(self.end)})"
+
+
+def normalize_ranges(ranges: List[DayRange]) -> List[DayRange]:
+    """Merges overlapping and consecutive ranges into a single range."""
+    if not ranges:
+        return ranges
+
+    result = []
+    current_range = DayRange(ranges[0].start, ranges[0].end)
+    for r in ranges[1:]:
+        if current_range.end + datetime.timedelta(days=1) >= r.start:
+            current_range.end = r.end
+        else:
+            result.append(current_range)
+            current_range = DayRange(r.start, r.end)
+    result.append(current_range)
+    return result
+
+
+class DayRangeSet:
+    def __init__(self, ranges: Iterable[DayRange]):
+        self.ranges = normalize_ranges(sorted(ranges, key=lambda r: r.start))
+
+    @property
+    def empty(self):
+        return not self.ranges
+
+    @property
+    def start(self):
+        return self.ranges[0].start if not self.empty else None
+
+    @property
+    def end(self):
+        return self.ranges[-1].end if not self.empty else None
+
+    def get_days(self):
+        """Iterate over every day in the included ranges in increasing order."""
+        cur = datetime.date(1900, 1, 1)
+        for r in self.ranges:
+            # Ranges can overlap, so we only jump to the start if it is in the future
+            if r.start > cur:
+                cur = r.start
+            while cur <= r.end:
+                yield cur
+                cur += datetime.timedelta(days=1)
+
+    def get_covering_weeks(self):
+        """Get DayRanges from Monday to Sunday to cover all days in all ranges."""
+        prev_monday = datetime.date(1900, 1, 1)
+        for r in self.ranges:
+            monday = r.start - datetime.timedelta(days=r.start.weekday())
+            if monday == prev_monday:
+                # We already had this week, skip ahead
+                monday = monday + datetime.timedelta(days=7)
+                if monday > r.end:
+                    # Already covered the whole range
+                    continue
+
+            while True:
+                sunday = monday + datetime.timedelta(days=6)
+                yield DayRange(monday, sunday)
+                prev_monday = monday
+                monday += datetime.timedelta(days=7)
+                if sunday >= r.end:
+                    break
+
+    def intersect(self, other: 'DayRangeSet') -> 'DayRangeSet':
+        """Return a DateRangeSet that contains only days present in both sets."""
+        ranges = []
+        i, j = 0, 0
+        while i < len(self.ranges) and j < len(other.ranges):
+            if self.ranges[i].end < other.ranges[j].start:
+                i += 1  # our range is completely before the other
+            elif self.ranges[i].start > other.ranges[j].end:
+                j += 1  # our range is completely after the other
+            else:
+                # We have some sort of overlap.
+                start = max(self.ranges[i].start, other.ranges[j].start)
+                end = min(self.ranges[i].end, other.ranges[j].end)
+                ranges.append(DayRange(start, end))
+                # The range that ends earlier gets fully consumed
+                if self.ranges[i].end < other.ranges[j].end:
+                    i += 1
+                elif self.ranges[i].end > other.ranges[j].end:
+                    j += 1
+                else:  # Both end on the same day -> both consumed
+                    i += 1
+                    j += 1
+        return DayRangeSet(ranges)
+
+    def subtract(self, other: 'DayRangeSet') -> 'DayRangeSet':
+        """Return a DateRangeSet that contains only days present in this set but not other."""
+        ranges = []
+        i, j = 0, 0
+        while i < len(self.ranges) and j < len(other.ranges):
+            if self.ranges[i].end < other.ranges[j].start:
+                ranges.append(self.ranges[i])  # our range is completely before the other --> keep it
+                i += 1
+            elif self.ranges[i].start > other.ranges[j].end:
+                j += 1  # our range is completely after the other
+            else:
+                # We have some sort of overlap.
+                start = self.ranges[i].start
+                for r in other.ranges[j:]:
+                    if start < r.start:
+                        # Keep part before overlapping range
+                        ranges.append(DayRange(start, r.start - datetime.timedelta(days=1)))
+                    start = r.end + datetime.timedelta(days=1)
+                    if start > self.ranges[i].end:
+                        break
+                if start <= self.ranges[i].end:
+                    # Keep any reminder
+                    ranges.append(DayRange(start, self.ranges[i].end))
+                i += 1  # our range is consumed, but the other range could still overlap the next one.
+        # Any ranges we haven't consumed yet can be kept
+        ranges.extend(self.ranges[i:])
+        return DayRangeSet(ranges)
+
+    def __repr__(self):
+        return f'DayRangeSet({repr(self.ranges)})'
+
+
+class Installation:
+    """CLI context for tracking the selected installation."""
+    id: str
+
+    def __init__(self, installation_id: str):
+        self.id = installation_id
+
+
+class DataSelection:
+    """CLI context for tracking the time-range of interest and available data."""
+    _session: Session
+    _installation_id: str
+    _data_type: Optional[str]
+    _date_from: Optional[str]
+    _date_to: Optional[str]
+    limit: int
+
+    def __init__(self, session: Session, installation_id: str, data_type: Optional[str],
+                 date_from: Optional[str], date_to: Optional[str], limit: int):
+        self._session = session
+        self._installation_id = installation_id
+        self._data_type = data_type
+        self._date_from = date_from
+        self._date_to = date_to
+        self.limit = limit
+
+    @cached_property
+    def _properties(self) -> List[IDProperty]:
+        return self._session.get_installation_data(self._installation_id)['status']
+
+    @cached_property
+    def _mapped_properties(self) -> Dict[str, IDProperty]:
+        return {x['property']: x for x in self._properties}
+
+    @cached_property
+    def data_type(self):
+        if self._data_type:
+            return self._data_type
+
+        if 'VERB_15MIN' in self._mapped_properties:
+            return 'PK_VERB_15MIN'
+        else:
+            return 'PK_VERB_TAG_EDM'
+
+    @cached_property
+    def property_key(self) -> str:
+        # The type used in the API and the property key seem to differ by a PK_ prefix...
+        pkey = self.data_type
+        if pkey.startswith('PK_'):
+            pkey = pkey[3:]
+        return pkey
+
+    @cached_property
+    def date_to(self) -> str:
+        if self._date_to:
+            return self._date_to
+
+        api_data_to = self._mapped_properties.get(self.property_key, {}).get('bis')
+        if not api_data_to:
+            return format_api_date(datetime.date.today())
+
+        if parse_zrh_day(api_data_to) > datetime.date.today() - datetime.timedelta(days=3):
+            # The API-provided timeranges when getting properties seems to lag behind the actual data,
+            # so if it's very recent, we'll just round up to today.
+            return format_api_date(datetime.date.today())
+        return api_data_to
+
+    @cached_property
+    def date_from(self) -> str:
+        if self._date_from:
+            return self._date_from
+        return format_api_date(parse_zrh_day(self.date_to) - datetime.timedelta(days=7))
+
+    @cached_property
+    def explicit_daterange(self) -> bool:
+        return self._date_from is not None or self._date_to is not None
+
+    @cached_property
+    def earliest_day(self) -> str:
+        return self._mapped_properties[self.property_key]['ab'] or None
+
+    @cached_property
+    def latest_day(self) -> str:
+        return self._mapped_properties[self.property_key]['bis'] or None
+
+    @cached_property
+    def available_ranges(self) -> DayRangeSet:
+        """The ranges the API claims to be available.
+
+        These do not have to be continuous, there can for example be gaps in the 15min data depending
+        on when it was activated. It also seems possible for newer data to already exist."""
+        return DayRangeSet([DayRange(parse_zrh_day(x['ab']), parse_zrh_day(x['bis'])) for
+                            x in self._properties if x['property'] == self.property_key])
+
+    @cached_property
+    def requested_ranges(self) -> DayRangeSet:
+        """The ranges the user requested or all available ranges if nothing has been specified."""
+        if self.explicit_daterange:
+            return DayRangeSet([DayRange(parse_zrh_day(self.date_from), parse_zrh_day(self.date_to))])
+
+        result = self.available_ranges
+        if result.ranges:
+            result = DayRangeSet(result.ranges +
+                                 # Make sure the corrections in date_to are also applied here.
+                                 [DayRange(result.end, parse_zrh_day(self.date_to))])
+        return result
+
+    def requested_weeks(self) -> Iterable[DayRange]:
+        """Convenience wrapper to iterate over the weeks in requested_ranges."""
+        if (len(self.requested_ranges.ranges) == 1 and
+                (self.requested_ranges.ranges[0].end - self.requested_ranges.ranges[0].start).days <= 7):
+            return [self.requested_ranges.ranges[0]]  # Requested a week or less, so just return that.
+        return itertools.islice(self.requested_ranges.get_covering_weeks(), self.limit)
+
+
+pass_session = click.make_pass_decorator(Session)
+pass_installation = click.make_pass_decorator(Installation)
+pass_data = click.make_pass_decorator(DataSelection)

ekzexport-0.1.0.dist-info/LICENSE

@@ -0,0 +1,174 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

ekzexport-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.1
+Name: ekzexport
+Version: 0.1.0
+Summary: CLI and data exporter for the myEKZ customer portal.
+Home-page: https://github.com/mensi/ekzexport
+Author: Manuel Stocker
+Author-email: mensi@mensi.ch
+License: Apache-2.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: click
+Requires-Dist: beautifulsoup4
+Requires-Dist: rich
+Requires-Dist: platformdirs
+Requires-Dist: tzdata
+Provides-Extra: influx
+Requires-Dist: influxdb-client ; extra == 'influx'
+
+# ekzexport
+
+Exporter for EKZ data provided on the http://my.ekz.ch customer portal.
+
+## Installing
+
+Get it from PyPI:
+
+```console
+$ python -m pip install ekzexport
+```
+
+You can then use the `ekzexport` CLI.
+
+## Example Usage
+
+To authenticate, you can either put your credentials into a JSON file
+`ekzexport.json` in your home directory:
+
+```json
+{
+  "user": "myusername",
+  "password": "mypassword"
+}
+```
+
+Or use the `--user` and `--password` options. The following examples use a JSON
+file.
+
+First, list your contracts to find the installation ID of interest:
+
+```console
+$ ekzexport overview
+                                        Contracts                                        
+                  ╷                                      ╷              ╷
+  Installation ID │ Address                              │ Move-in Date │ Move-out Date 
+╺━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━┿━━━━━━━━━━━━━━━╸
+  123             │ Somestreet 1, 8000 Someplace         │ 2010-01-01   │ 2020-01-01
+  456             │ Some Other Street 2, 8001 Otherplace │ 2020-01-02   │
+                  ╵                                      ╵              ╵
+```
+
+With the installation ID, we can then figure out what kind of data is available
+for your account:
+
+```console
+$ ekzexport installation 456 properties
+                 Properties                 
+                 ╷            ╷
+  Property       │ From       │ Until      
+╺━━━━━━━━━━━━━━━━┿━━━━━━━━━━━━┿━━━━━━━━━━━━╸
+  CONTRACT       │ 2020-01-02 │ 2024-05-01
+  SMART_METER    │ 2020-01-02 │ 2024-05-01
+  VERB_15MIN     │ 2020-01-02 │ 2024-05-01
+  VERB_TAG_EDM   │ 2020-01-02 │ 2024-05-01
+  VERB_TAG_METER │ 2020-01-02 │ 2024-05-01
+                 ╵            ╵
+```
+
+If you do not see any entry for 15 minute values, you likely have to enable
+granular data on myEKZ first.
+
+You can print consumption data to get an idea what is available:
+
+```console
+$ ekzexport installation 456 data --type PK_VERB_TAG_EDM --from 2024-04-01 --to 2024-04-02 show
+                 Consumption Data                 
+                      ╷        ╷        ╷
+  Time                │ kWh    │ Tariff │ Status 
+╺━━━━━━━━━━━━━━━━━━━━━┿━━━━━━━━┿━━━━━━━━┿━━━━━━━━╸
+  2024-04-01 00:00:00 │ 12.123 │ NT     │ VALID
+  2024-04-01 00:00:00 │ 10.123 │ HT     │ VALID
+  2024-04-02 00:00:00 │ 12.678 │ NT     │ VALID
+  2024-04-02 00:00:00 │ 8.678  │ HT     │ VALID
+                      ╵        ╵        ╵
+```
+
+But the more interesting use-case is to export data. Available exporters are:
+
+ - `csv` to sync data to a CSV file in the same format as myEKZ offers
+ - `influxdb` to sync data to an InfluxDB 2.x server
+
+The CLI's help command will provide further detail on the exporter-specific
+options, for example:
+
+```console
+$ ekzexport installation 456 data export csv --help
+```
+
+## Running Exports Periodically
+
+If you're using a Linux distribution using systemd, you can create a service
+and trigger to run the export periodically. To do so, create
+`/etc/systemd/system/ekzexport.service` with something like:
+
+```ini
+[Unit]
+Description=Pull EKZ data
+
+[Service]
+Type=oneshot
+ExecStart=/path/to/ekzexport/venv/bin/ekzexport installation 456 data export csv -f data.csv
+WorkingDirectory=/path/to/ekzexport
+```
+
+This example assumes you created a Python virtualenv to install ekzexport
+in (which keeps the dependencies local in the venv). You can also
+set up an `OnFailure` hook to send emails in case the export fails.
+
+A corresponding timer can look something like this in `/etc/systemd/system/ekzexport.timer`:
+
+```ini
+[Unit]
+Description=Run ekzexport once a day
+
+[Timer]
+OnCalendar=*-*-* 04:00:00
+RandomizedDelaySec=30m
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+```
+
+Please keep the randomized delay to avoid myEKZ getting a flood of requests
+at exactly 04:00 every night. Remember to enable and start the timer.

ekzexport-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+ekzexport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ekzexport/apitypes.py,sha256=ZFLHzttT6hQDcGEzapJtisOPPL2Z0eOJe5ORNx5L6ws,2489
+ekzexport/cli.py,sha256=ThyW3nuascx24enbUOGRrOVz6CZIqU6qjnqf9mhz4Ms,6325
+ekzexport/session.py,sha256=Lq5R7rI3TT6RkfthrwwfeNoQo_ly_CEUcN3a_X_ZSO8,3151
+ekzexport/timeutil.py,sha256=sM2d2_kST_tgtijsRyAVwgKGnbQG-H0gowyBC_OdSeY,2674
+ekzexport/util.py,sha256=svfK6s5nQld8xm5wxHdyi3X3GnP04Sm01hFNl_5yM2o,10640
+ekzexport-0.1.0.dist-info/LICENSE,sha256=zE1N4JILDTkSIDtdmqdnKKxKEQh_VdqeoAV2230eNOI,10141
+ekzexport-0.1.0.dist-info/METADATA,sha256=U1KWu8ri-7DsKj2mu439whtrMaznsCbWKd7BkhjBAys,5412
+ekzexport-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+ekzexport-0.1.0.dist-info/entry_points.txt,sha256=k2S1WlSS8Kl0cDhNUNVJs23mdriaBNasuzo801dvzTo,49
+ekzexport-0.1.0.dist-info/top_level.txt,sha256=3m0B3x46lL2kHRmG21Eg5wvnCq5TqL4ctUcusMmb8PE,10
+ekzexport-0.1.0.dist-info/RECORD,,

ekzexport-0.1.0.dist-info/WHEEL

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

ekzexport-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ekzexport = ekzexport.cli:main

ekzexport-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ekzexport