aemo-mdff-reader 2.0.2__py3-none-any.whl

aemo_mdff_reader/types.py

@@ -0,0 +1,437 @@
+"""Lightweight data classes for parsed NEM12/NEM13 records.
+
+These types form the public surface of the streaming parser. They use
+``__slots__`` to keep per-row memory and allocation cost low when
+processing large files (millions of intervals).
+
+Each class exposes a ``to_dict()`` method for cheap conversion to a
+``dict`` — useful for JSON serialisation, dict-comprehension filtering,
+and bridging to systems that expect mappings.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+def _slots_to_dict(obj: Any) -> Dict[str, Any]:
+    """Return a ``dict`` of an object's ``__slots__`` values."""
+    return {slot: getattr(obj, slot) for slot in obj.__slots__}
+
+
+def _quality_flag(quality_method: str) -> str:
+    """Return the 1-character quality flag from a ``QMM`` field.
+
+    The AEMO MDFF v2.6 spec defines QualityMethod as a 3-character
+    string ``QMM`` where ``Q`` is the 1-char quality flag (one of
+    ``A``, ``E``, ``F``, ``S``, ``V``) and ``MM`` is the 2-char method
+    flag (numeric, e.g. ``"53"``). When ``Q`` is ``A`` or ``V`` the
+    method flag is omitted, so the field may be just one character.
+    Empty input returns an empty string.
+    """
+    return quality_method[:1]
+
+
+def _method_flag(quality_method: str) -> str:
+    """Return the 2-character method flag from a ``QMM`` field.
+
+    Empty if the underlying QualityMethod has no method component
+    (e.g. quality flag ``"A"``).
+    """
+    return quality_method[1:3]
+
+
+class Header:
+    """100 record — file header."""
+
+    __slots__ = ("datetime", "from_participant", "to_participant", "version")
+
+    def __init__(
+        self,
+        version: str,
+        datetime: Optional[datetime],
+        from_participant: str,
+        to_participant: str,
+    ) -> None:
+        self.version = version
+        self.datetime = datetime
+        self.from_participant = from_participant
+        self.to_participant = to_participant
+
+    def __repr__(self) -> str:
+        return (
+            f"Header(version={self.version!r}, datetime={self.datetime!r}, "
+            f"from_participant={self.from_participant!r}, "
+            f"to_participant={self.to_participant!r})"
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name."""
+        return _slots_to_dict(self)
+
+
+class NMIDetails:
+    """200 record — NMI / channel details."""
+
+    __slots__ = (
+        "interval_length",
+        "mdm_data_stream_identifier",
+        "meter_serial_number",
+        "next_scheduled_read_date",
+        "nmi",
+        "nmi_configuration",
+        "nmi_suffix",
+        "register_id",
+        "uom",
+    )
+
+    def __init__(
+        self,
+        nmi: str,
+        nmi_configuration: str,
+        register_id: str,
+        nmi_suffix: str,
+        mdm_data_stream_identifier: str,
+        meter_serial_number: str,
+        uom: str,
+        interval_length: int,
+        next_scheduled_read_date: Optional[datetime],
+    ) -> None:
+        self.nmi = nmi
+        self.nmi_configuration = nmi_configuration
+        self.register_id = register_id
+        self.nmi_suffix = nmi_suffix
+        self.mdm_data_stream_identifier = mdm_data_stream_identifier
+        self.meter_serial_number = meter_serial_number
+        self.uom = uom
+        self.interval_length = interval_length
+        self.next_scheduled_read_date = next_scheduled_read_date
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name."""
+        return _slots_to_dict(self)
+
+
+class IntervalReading:
+    """A single interval reading — one cell of a 300 record.
+
+    Notes
+    -----
+    ``value`` is always a ``float``. Empty cells in the source NEM12
+    file are coerced to ``0.0`` so a single missing cell does not fail
+    an entire row. Use ``quality_method`` (e.g. ``"S"`` for substituted,
+    ``"F"`` for failed, ``"N"`` for null) to distinguish a real zero
+    from a missing reading.
+    """
+
+    __slots__ = (
+        "interval_date",
+        "interval_end",
+        "interval_index",
+        "interval_length",
+        "interval_start",
+        "meter_serial_number",
+        "msats_load_datetime",
+        "nmi",
+        "nmi_suffix",
+        "quality_method",
+        "reason_code",
+        "reason_description",
+        "register_id",
+        "uom",
+        "update_datetime",
+        "value",
+    )
+
+    def __init__(
+        self,
+        nmi: str,
+        meter_serial_number: str,
+        register_id: str,
+        nmi_suffix: str,
+        uom: str,
+        interval_length: int,
+        interval_date: datetime,
+        interval_start: datetime,
+        interval_end: datetime,
+        interval_index: int,
+        value: float,
+        quality_method: str,
+        reason_code: Optional[int],
+        reason_description: str,
+        update_datetime: Optional[datetime],
+        msats_load_datetime: Optional[datetime],
+    ) -> None:
+        self.nmi = nmi
+        self.meter_serial_number = meter_serial_number
+        self.register_id = register_id
+        self.nmi_suffix = nmi_suffix
+        self.uom = uom
+        self.interval_length = interval_length
+        self.interval_date = interval_date
+        self.interval_start = interval_start
+        self.interval_end = interval_end
+        self.interval_index = interval_index
+        self.value = value
+        self.quality_method = quality_method
+        self.reason_code = reason_code
+        self.reason_description = reason_description
+        self.update_datetime = update_datetime
+        self.msats_load_datetime = msats_load_datetime
+
+    @property
+    def quality_flag(self) -> str:
+        """The 1-character quality flag from ``quality_method`` (e.g. ``"A"``).
+
+        See AEMO MDFF v2.6 Appendix C and :data:`aemo_mdff_reader.spec.QUALITY_FLAGS`.
+        """
+        return _quality_flag(self.quality_method)
+
+    @property
+    def method_flag(self) -> str:
+        """The 2-character method flag from ``quality_method`` (e.g. ``"53"``).
+
+        Empty when the quality flag does not require a method (e.g. ``"A"``).
+        """
+        return _method_flag(self.quality_method)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name.
+
+        ``quality_flag`` and ``method_flag`` are derived from
+        ``quality_method`` and not included; access them directly.
+        """
+        return _slots_to_dict(self)
+
+
+class IntervalEvent:
+    """400 record — quality/event flag covering a range of intervals."""
+
+    __slots__ = (
+        "end_interval",
+        "interval_date",
+        "meter_serial_number",
+        "nmi",
+        "quality_method",
+        "reason_code",
+        "reason_description",
+        "register_id",
+        "start_interval",
+    )
+
+    def __init__(
+        self,
+        nmi: str,
+        meter_serial_number: str,
+        register_id: str,
+        interval_date: datetime,
+        start_interval: int,
+        end_interval: int,
+        quality_method: str,
+        reason_code: Optional[int],
+        reason_description: str,
+    ) -> None:
+        self.nmi = nmi
+        self.meter_serial_number = meter_serial_number
+        self.register_id = register_id
+        self.interval_date = interval_date
+        self.start_interval = start_interval
+        self.end_interval = end_interval
+        self.quality_method = quality_method
+        self.reason_code = reason_code
+        self.reason_description = reason_description
+
+    @property
+    def quality_flag(self) -> str:
+        """The 1-character quality flag from ``quality_method``."""
+        return _quality_flag(self.quality_method)
+
+    @property
+    def method_flag(self) -> str:
+        """The 2-character method flag from ``quality_method``."""
+        return _method_flag(self.quality_method)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name."""
+        return _slots_to_dict(self)
+
+
+class AccumulationReading:
+    """250 record — NEM13 NMI accumulation / manual-read data.
+
+    Each 250 record represents a previous + current register read pair
+    plus a calculated quantity (consumption between the two reads).
+
+    .. note::
+       ``direction_indicator`` is stored as the raw string from the
+       file. AEMO MDFF v2.6 §5.3 restricts it to ``"I"`` (Import) or
+       ``"E"`` (Export), but real-world files occasionally contain
+       ``"B"`` (bi-directional) or ``"N"`` (not applicable). The parser
+       accepts either case and leaves enforcement to the caller; see
+       :data:`aemo_mdff_reader.spec.DIRECTION_INDICATORS` for the spec set.
+    """
+
+    __slots__ = (
+        "current_quality_method",
+        "current_reason_code",
+        "current_reason_description",
+        "current_register_read",
+        "current_register_read_datetime",
+        "direction_indicator",
+        "mdm_data_stream_identifier",
+        "meter_serial_number",
+        "msats_load_datetime",
+        "next_scheduled_read_date",
+        "nmi",
+        "nmi_configuration",
+        "nmi_suffix",
+        "previous_quality_method",
+        "previous_reason_code",
+        "previous_reason_description",
+        "previous_register_read",
+        "previous_register_read_datetime",
+        "quantity",
+        "register_id",
+        "uom",
+        "update_datetime",
+    )
+
+    def __init__(
+        self,
+        nmi: str,
+        nmi_configuration: str,
+        register_id: str,
+        nmi_suffix: str,
+        mdm_data_stream_identifier: str,
+        meter_serial_number: str,
+        direction_indicator: str,
+        previous_register_read: float,
+        previous_register_read_datetime: Optional[datetime],
+        previous_quality_method: str,
+        previous_reason_code: Optional[int],
+        previous_reason_description: str,
+        current_register_read: float,
+        current_register_read_datetime: Optional[datetime],
+        current_quality_method: str,
+        current_reason_code: Optional[int],
+        current_reason_description: str,
+        quantity: float,
+        uom: str,
+        next_scheduled_read_date: Optional[datetime],
+        update_datetime: Optional[datetime],
+        msats_load_datetime: Optional[datetime],
+    ) -> None:
+        self.nmi = nmi
+        self.nmi_configuration = nmi_configuration
+        self.register_id = register_id
+        self.nmi_suffix = nmi_suffix
+        self.mdm_data_stream_identifier = mdm_data_stream_identifier
+        self.meter_serial_number = meter_serial_number
+        self.direction_indicator = direction_indicator
+        self.previous_register_read = previous_register_read
+        self.previous_register_read_datetime = previous_register_read_datetime
+        self.previous_quality_method = previous_quality_method
+        self.previous_reason_code = previous_reason_code
+        self.previous_reason_description = previous_reason_description
+        self.current_register_read = current_register_read
+        self.current_register_read_datetime = current_register_read_datetime
+        self.current_quality_method = current_quality_method
+        self.current_reason_code = current_reason_code
+        self.current_reason_description = current_reason_description
+        self.quantity = quantity
+        self.uom = uom
+        self.next_scheduled_read_date = next_scheduled_read_date
+        self.update_datetime = update_datetime
+        self.msats_load_datetime = msats_load_datetime
+
+    @property
+    def previous_quality_flag(self) -> str:
+        """1-character quality flag for the *previous* register read."""
+        return _quality_flag(self.previous_quality_method)
+
+    @property
+    def previous_method_flag(self) -> str:
+        """2-character method flag for the *previous* register read."""
+        return _method_flag(self.previous_quality_method)
+
+    @property
+    def current_quality_flag(self) -> str:
+        """1-character quality flag for the *current* register read."""
+        return _quality_flag(self.current_quality_method)
+
+    @property
+    def current_method_flag(self) -> str:
+        """2-character method flag for the *current* register read."""
+        return _method_flag(self.current_quality_method)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name."""
+        return _slots_to_dict(self)
+
+
+class B2BDetails:
+    """500 (NEM12) / 550 (NEM13) record — B2B transaction details.
+
+    The 500 record carries a single transaction (TransCode +
+    RetServiceOrder + ReadDateTime + IndexRead). The 550 record carries
+    a paired previous/current transaction. We surface them with the
+    same class and a ``record_kind`` discriminator (``"500"`` or
+    ``"550"``) so callers can branch when needed.
+
+    Fields that do not apply to the current ``record_kind`` are set to
+    ``None`` (not ``""``), so callers can distinguish "structurally
+    absent for this record kind" from "present but empty in source"::
+
+        if b.record_kind == "550":
+            assert b.previous_trans_code is not None  # set
+            assert b.trans_code is None                # not in this kind
+    """
+
+    __slots__ = (
+        "current_ret_service_order",
+        "current_trans_code",
+        "index_read",
+        "previous_ret_service_order",
+        "previous_trans_code",
+        "read_datetime",
+        "record_kind",
+        "ret_service_order",
+        "trans_code",
+    )
+
+    def __init__(
+        self,
+        record_kind: str,
+        trans_code: Optional[str] = None,
+        ret_service_order: Optional[str] = None,
+        read_datetime: Optional[datetime] = None,
+        index_read: Optional[str] = None,
+        previous_trans_code: Optional[str] = None,
+        previous_ret_service_order: Optional[str] = None,
+        current_trans_code: Optional[str] = None,
+        current_ret_service_order: Optional[str] = None,
+    ) -> None:
+        self.record_kind = record_kind
+        self.trans_code = trans_code
+        self.ret_service_order = ret_service_order
+        self.read_datetime = read_datetime
+        self.index_read = index_read
+        self.previous_trans_code = previous_trans_code
+        self.previous_ret_service_order = previous_ret_service_order
+        self.current_trans_code = current_trans_code
+        self.current_ret_service_order = current_ret_service_order
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return this record as a plain dict keyed by field name."""
+        return _slots_to_dict(self)
+
+
+__all__ = [
+    "AccumulationReading",
+    "B2BDetails",
+    "Header",
+    "IntervalEvent",
+    "IntervalReading",
+    "NMIDetails",
+]

aemo_mdff_reader-2.0.2.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: aemo-mdff-reader
+Version: 2.0.2
+Summary: Fast streaming reader for AEMO MDFF NEM12 / NEM13 metering files. Zero required dependencies.
+Author: Utilified Holdings Pty Ltd
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Utilified/aemo-mdff-reader
+Project-URL: Repository, https://github.com/Utilified/aemo-mdff-reader
+Project-URL: Issues, https://github.com/Utilified/aemo-mdff-reader/issues
+Project-URL: Changelog, https://github.com/Utilified/aemo-mdff-reader/blob/main/CHANGELOG.md
+Keywords: nem12,nem13,aemo,energy,metering,australia,mdff
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.3; extra == "pandas"
+Provides-Extra: parquet
+Requires-Dist: pandas>=1.3; extra == "parquet"
+Requires-Dist: pyarrow>=10; extra == "parquet"
+Provides-Extra: mysql
+Requires-Dist: PyMySQL>=1.0; extra == "mysql"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Requires-Dist: pandas>=1.3; extra == "dev"
+Requires-Dist: pyarrow>=10; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Requires-Dist: packaging>=24.2; extra == "dev"
+Dynamic: license-file
+
+# aemo-mdff-reader
+
+[![CI](https://github.com/Utilified/aemo-mdff-reader/actions/workflows/ci.yml/badge.svg)](https://github.com/Utilified/aemo-mdff-reader/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/aemo-mdff-reader.svg)](https://pypi.org/project/aemo-mdff-reader/)
+[![Python versions](https://img.shields.io/pypi/pyversions/aemo-mdff-reader.svg)](https://pypi.org/project/aemo-mdff-reader/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Fast, zero-dependency streaming reader for AEMO **NEM12** and **NEM13**
+metering files. Implements AEMO MDFF (Meter Data File Format) v2.6.
+
+- O(1) memory — iterate through millions of intervals.
+- Pure stdlib core; pandas / PyMySQL are opt-in extras.
+- ~2 M readings/sec on the columnar fast path.
+- Includes an `aemo-mdff-reader` CLI.
+
+## Install
+
+```bash
+pip install aemo-mdff-reader
+
+# optional extras
+pip install aemo-mdff-reader[pandas]   # to_dataframe() / parquet
+pip install aemo-mdff-reader[mysql]    # SQL persistence
+```
+
+## Use
+
+```python
+from aemo_mdff_reader import parse
+
+for r in parse("metering.csv"):
+    print(r.nmi, r.interval_start, r.value, r.uom)
+```
+
+Or as a flat CSV / DataFrame:
+
+```python
+from aemo_mdff_reader import parse, write_csv, to_dataframe
+
+write_csv(parse("metering.csv"), "out.csv")     # no pandas
+df = to_dataframe("metering.csv")                # needs [pandas]
+```
+
+From the command line:
+
+```bash
+aemo-mdff-reader metering.csv -o out.csv
+aemo-mdff-reader metering.csv --validate                       # spec check
+aemo-mdff-reader metering.csv --nmi NMI1234567 --start 2024-01-01 --end 2024-01-31
+aemo-mdff-reader manual.csv --records accumulations            # NEM13
+```
+
+## Working with the data
+
+Each parsed record is a slots-based class with named attributes plus a
+`to_dict()` for JSON / dict pipelines:
+
+```python
+for r in parse("metering.csv"):
+    payload = r.to_dict()              # {"nmi": "...", "value": 0.12, ...}
+    print(r.quality_flag, r.method_flag)  # split of the QMM field, e.g. "S", "52"
+```
+
+For aggregation, `aemo_mdff_reader.aggregate` provides streaming helpers:
+
+```python
+from aemo_mdff_reader import parse
+from aemo_mdff_reader.aggregate import group_by_nmi, daily_totals
+
+for key, group in group_by_nmi(parse("metering.csv")):
+    # key = ChannelKey(nmi, register_id, nmi_suffix)
+    intervals = list(group)
+
+for day in daily_totals(parse("metering.csv")):
+    # day.total, day.interval_count, day.unique_quality_flags
+    print(day.nmi, day.interval_date.date(), day.total, day.uom)
+```
+
+End-to-end recipes — load + inspect, daily roll-up, filter to pandas,
+spec validation — live in [`examples/`](examples/).
+
+## API at a glance
+
+| You want                              | Call                          |
+| ------------------------------------- | ----------------------------- |
+| 300 interval readings (NEM12)         | `parse(src)`                  |
+| 250 accumulations (NEM13)             | `parse_accumulations(src)`    |
+| Both, in file order                   | `parse_all(src)`              |
+| 400 quality / event flags             | `parse_events(src)`           |
+| 500 / 550 B2B transactions            | `parse_b2b(src)`              |
+| Just the 100 header                   | `parse_header(src)`           |
+| Build a pandas DataFrame              | `to_dataframe(src)`           |
+| Write a flat CSV (no pandas)          | `write_csv(rows, out)`        |
+| Validate against AEMO MDFF v2.6       | `validate_file(src)`          |
+| Compute / verify an NMI checksum      | `nmi_checksum`, `validate_nmi`|
+| Group readings by NMI / channel       | `aggregate.group_by_nmi(rows)`|
+| Roll up to daily totals               | `aggregate.daily_totals(rows)`|
+| Convert any record to a plain dict    | `r.to_dict()`                 |
+
+`src` can be a path, a file-like object, an iterable of CSV lines, or
+an iterable of pre-split rows. The v1 `NEMReader` facade
+(`read_from_file`, `to_dataframe`, `to_csv`) still works.
+
+Each `parse(...)` yields an `IntervalReading` with `nmi`,
+`meter_serial_number`, `register_id`, `nmi_suffix`, `uom`,
+`interval_length`, `interval_date`, `interval_start`, `interval_end`,
+`interval_index`, `value`, `quality_method`, `reason_code`,
+`reason_description`, `update_datetime`, `msats_load_datetime`. See
+the type stubs (`from aemo_mdff_reader import IntervalReading`) for the
+exact signatures.
+
+## Notes
+
+- **Spec**: AEMO Meter Data File Format Specification NEM12 & NEM13,
+  **v2.6** (effective 29 September 2024). Records `100`, `200`, `250`,
+  `300`, `400`, `500`, `550`, `900` are all surfaced; unknown indicators
+  are ignored. Allowed values for quality flags, transaction codes,
+  reason codes, units of measure, and direction indicators are exposed
+  as constants in `aemo_mdff_reader.spec` for callers that want stricter
+  validation than the parser performs.
+- **Tolerant**: UTF-8 BOM is consumed silently, LF and CRLF both work,
+  and empty interval cells are coerced to `0.0` (use `quality_method`
+  to distinguish missing from zero). Datetime fields accept the spec
+  forms (`YYYYMMDD`, `YYYYMMDDhhmmss`) and a few common non-spec
+  variants (`YYYY-MM-DD`, ISO `YYYY-MM-DDTHH:MM:SS`, with or without a
+  `Z` / `±HH:MM` / `±HHMM` timezone suffix — the suffix is stripped
+  and parsed datetimes are returned naive). `direction_indicator` on
+  250 records passes through whatever the file emits; the spec set is
+  `spec.DIRECTION_INDICATORS = {"I", "E"}` but `B` and `N` appear in
+  the wild. The parser also accepts non-spec IntervalLengths (1, 60,
+  etc.); strict callers should compare against
+  `spec.ALLOWED_INTERVAL_LENGTHS` (= `{5, 15, 30}`).
+- **Migration from v1**: `NEMReader` still works. The internal
+  `aemo_mdff_reader.nemstructure` package is gone — see the API table
+  above. `pandas` is now opt-in. See `CHANGELOG.md` for details.
+
+## Performance
+
+420,480 readings (4 NMIs × 365 days × 5-min, 2.8 MiB CSV), Python 3.11:
+
+| Operation                          | Time   |
+| ---------------------------------- | -----: |
+| `for r in parse(path): ...`        | 0.45 s |
+| `parse_to_columns(path)`           | 0.21 s |
+| `to_dataframe(path)` (pandas)      | 0.76 s |
+
+~2.7× faster than v1 end-to-end; reproduce with
+`python benchmarks/bench_parser.py`.
+
+## Large files
+
+The parser is built to scale to gigabyte-class NEM12 files without
+loading them into RAM. Measured peak memory delta on a synthetic
+**10.5 M-reading file** (100 NMIs × 365 days × 5-min, 71 MiB CSV),
+Python 3.12:
+
+| API                                      | Memory profile | Peak Δ |
+| ---------------------------------------- | -------------- | -----: |
+| `for r in parse(path): ...`              | streaming      | **1.3 MiB** |
+| `daily_totals(parse(path))`              | streaming      | **0 MiB** |
+| `write_csv(parse(path), out)`            | streaming      | **0 MiB** |
+| `iter_dataframes(path, chunk_size=N)`    | bounded O(N)   | **~30 MiB / 100k** |
+| `iter_columns_chunks(path, chunk_size=N)`| bounded O(N)   | **~10 MiB / 100k** |
+| `parse_to_columns(path)`                 | full materialise | ~600 MiB |
+| `list(parse(path))` / `to_dataframe(path)` / `NEMReader.read_from_file()` | full materialise | ~2.5 GiB |
+
+Rule of thumb: stay on the streaming or chunked APIs for any file
+larger than a few hundred MiB. The chunked variants make pandas-based
+workflows safe on arbitrarily large inputs:
+
+```python
+from aemo_mdff_reader import iter_dataframes
+
+# Process a multi-GiB file 50,000 readings at a time.
+for df in iter_dataframes("huge.csv", chunk_size=50_000):
+    daily = df.groupby(["NMI", "IntervalDate"])["Value"].sum()
+    daily.to_csv("out.csv", mode="a", header=False)
+```
+
+The `NEMReader` facade and `to_dataframe(path)` materialise their
+inputs by design (so `len(reader)` and `df.iloc[...]` work). Avoid
+them for files that won't fit in RAM.
+
+## Development
+
+```bash
+git clone https://github.com/Utilified/aemo-mdff-reader.git
+cd aemo-mdff-reader
+pip install -e .[dev]
+pytest
+```
+
+CI runs ruff, mypy --strict, the test matrix on Python 3.9 → 3.12 /
+Linux / macOS / Windows, `pip-audit`, `bandit`, and a wheel-install
+smoke test. Releases are signed with sigstore and published to PyPI
+via Trusted Publishing on tag.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

aemo_mdff_reader-2.0.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+aemo_mdff_reader/__init__.py,sha256=eYrHtmlt7NL7TgIFWWbWHYUY8q14RR4iNpMghv6JjNk,2068
+aemo_mdff_reader/aggregate.py,sha256=w5mqjWGuXasY6NHbOs9z5NherLP46BCXlvZcXGPFzcA,5594
+aemo_mdff_reader/cli.py,sha256=8qu9tPYKrCRak8f6-blGapgn6dASsxC4oY0FJd1l7ys,6830
+aemo_mdff_reader/parser.py,sha256=9Z6jXfEQSSlpO5HyTjE6xbeP3yzQV5gkPGP9dzwHZcA,45302
+aemo_mdff_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aemo_mdff_reader/reader.py,sha256=3uz56syk15j_2Jjt4TpGa-6Oy6NGpDNqshJDHKBTN_Q,3735
+aemo_mdff_reader/spec.py,sha256=xXepAicACY7LrqIkQ6WuixsxoJlneZ6OfjkMQYh8Vqo,7495
+aemo_mdff_reader/types.py,sha256=KylRqgemsF9swhx0n77I1kAxhJU9MPziEk8GRZcE-Ls,14648
+aemo_mdff_reader/sql/__init__.py,sha256=J3ZgIbl6fc8AjLUX9wkp_AhotRdG70jNlQdxt_QUY9w,798
+aemo_mdff_reader/sql/query.py,sha256=X0W4HQYcYAs86N0hJtjEZZ5nTOZtBh2znoB3yk8A-24,2787
+aemo_mdff_reader/sql/store.py,sha256=qcDczgUsoH_sL_YkjYcIXIW1dwlDRR8XqVJZVePIMbY,7080
+aemo_mdff_reader-2.0.2.dist-info/licenses/LICENSE,sha256=yaXP1AOkvdVKOZENv44yCYd-Gp1gMZJsCJ6Vq1lsAr8,1088
+aemo_mdff_reader-2.0.2.dist-info/METADATA,sha256=oBvv_YPQdi4XnSEDBp4QjabC-WYQlK8O2K8DYbi7l-g,10348
+aemo_mdff_reader-2.0.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+aemo_mdff_reader-2.0.2.dist-info/entry_points.txt,sha256=qyHPSMwKLwHcbmzdAnqtsp6uJGcT0dsLx97iLHsGhRY,63
+aemo_mdff_reader-2.0.2.dist-info/top_level.txt,sha256=_qHh4GyOKAePdT0u3oYVX7gz4hJKM_kvHx3NA5eSsAE,17
+aemo_mdff_reader-2.0.2.dist-info/RECORD,,