iec60870-parser 0.1.0__tar.gz

iec60870_parser-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Baller300000
+
+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.

iec60870_parser-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: iec60870-parser
+Version: 0.1.0
+Summary: Zero-dependency IEC 60870-5-101/103/104 frame parser
+Author: IEC 60870 Parser Contributors
+License: MIT
+Keywords: iec60870,scada,telemetry,industrial,protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# iec60870-parser
+
+A pure-Python, zero-runtime-dependency parser and validator for IEC 60870-5-101, -103, and -104 telemetry frames. It consumes one raw byte buffer at a time and returns a structured `ParseResult` with `VALID`, `INCOMPLETE`, or `CORRUPTED` status.
+
+## Install
+
+```text
+python -m pip install iec60870-parser
+```
+
+For a source checkout:
+
+```text
+python -m pip install -e .
+```
+
+## API
+
+```python
+from iec60870 import FrameStatus, T104Session, parse_frame
+
+result = parse_frame(raw_bytes, protocol="t104")
+if result.status is FrameStatus.VALID:
+    print(result.frame_type, result.fields)
+elif result.status is FrameStatus.INCOMPLETE:
+    # Retain the buffer and read more bytes.
+    pass
+else:
+    print(result.error)
+```
+
+`protocol` accepts `t101`, `t103`, `t104`, or `auto`. Explicit protocol selection is preferred for short/incomplete buffers. T101 uses a one-byte link address by default; T103 uses two bytes. Override either with `link_address_size=1` or `2`.
+
+For a stream connection, `T104Session` checks the receive sequence number of I-format APDUs and advances it after each valid telemetry frame:
+
+```python
+session = T104Session()
+result = session.parse(apdu_bytes)
+```
+
+## Wire formats
+
+### T101 and T103 FT1.2
+
+Variable frames are `68 L L 68 [control] [link address] [ASDU] [CS] 16`. `L` is the number of bytes from control through ASDU, and `CS` is the sum of those bytes modulo 256. Fixed frames are `10 [control] [link address] [CS] 16`; the fixed-frame helper uses the one-byte control/address layout defined by this package API.
+
+T103 uses the same FT1.2 framing and checksum but defaults to a two-byte link address. Companion-standard ASDU variations that are not Type 1 or Type 30 remain available through raw frame fields and can be decoded with `parse_asdu` using the relevant address widths.
+
+### T104 APCI
+
+An APDU is `68 L [four APCI control bytes] [ASDU]`. I-format control fields expose `send_sequence` and `receive_sequence`; S-format exposes the receive sequence; U-format exposes `STARTDT`, `STOPDT`, and `TESTFR` activation/confirmation names. APCI integers are decoded in little-endian wire order and sequence values are 15-bit values.
+
+## ASDU schema
+
+`parse_asdu` returns a dictionary containing `type_id`, `vsq`, `count`, `sequence`, `cot`, `common_address`, and `information_objects`. Type 1 objects decode a one-byte single-point value. Type 30 objects decode the one-byte value plus the seven raw CP56Time2a bytes. Unknown type identifiers are validated at the header/address level and leave their remaining bytes in `unparsed`.
+
+The parser validates bounds before every read, rejects trailing bytes when parsing a single frame, and does not perform socket or stream I/O.
+
+## Development
+
+```text
+python -m pip install pytest build
+python -m pytest
+python -m build
+```

iec60870_parser-0.1.0/README.md

@@ -0,0 +1,65 @@
+# iec60870-parser
+
+A pure-Python, zero-runtime-dependency parser and validator for IEC 60870-5-101, -103, and -104 telemetry frames. It consumes one raw byte buffer at a time and returns a structured `ParseResult` with `VALID`, `INCOMPLETE`, or `CORRUPTED` status.
+
+## Install
+
+```text
+python -m pip install iec60870-parser
+```
+
+For a source checkout:
+
+```text
+python -m pip install -e .
+```
+
+## API
+
+```python
+from iec60870 import FrameStatus, T104Session, parse_frame
+
+result = parse_frame(raw_bytes, protocol="t104")
+if result.status is FrameStatus.VALID:
+    print(result.frame_type, result.fields)
+elif result.status is FrameStatus.INCOMPLETE:
+    # Retain the buffer and read more bytes.
+    pass
+else:
+    print(result.error)
+```
+
+`protocol` accepts `t101`, `t103`, `t104`, or `auto`. Explicit protocol selection is preferred for short/incomplete buffers. T101 uses a one-byte link address by default; T103 uses two bytes. Override either with `link_address_size=1` or `2`.
+
+For a stream connection, `T104Session` checks the receive sequence number of I-format APDUs and advances it after each valid telemetry frame:
+
+```python
+session = T104Session()
+result = session.parse(apdu_bytes)
+```
+
+## Wire formats
+
+### T101 and T103 FT1.2
+
+Variable frames are `68 L L 68 [control] [link address] [ASDU] [CS] 16`. `L` is the number of bytes from control through ASDU, and `CS` is the sum of those bytes modulo 256. Fixed frames are `10 [control] [link address] [CS] 16`; the fixed-frame helper uses the one-byte control/address layout defined by this package API.
+
+T103 uses the same FT1.2 framing and checksum but defaults to a two-byte link address. Companion-standard ASDU variations that are not Type 1 or Type 30 remain available through raw frame fields and can be decoded with `parse_asdu` using the relevant address widths.
+
+### T104 APCI
+
+An APDU is `68 L [four APCI control bytes] [ASDU]`. I-format control fields expose `send_sequence` and `receive_sequence`; S-format exposes the receive sequence; U-format exposes `STARTDT`, `STOPDT`, and `TESTFR` activation/confirmation names. APCI integers are decoded in little-endian wire order and sequence values are 15-bit values.
+
+## ASDU schema
+
+`parse_asdu` returns a dictionary containing `type_id`, `vsq`, `count`, `sequence`, `cot`, `common_address`, and `information_objects`. Type 1 objects decode a one-byte single-point value. Type 30 objects decode the one-byte value plus the seven raw CP56Time2a bytes. Unknown type identifiers are validated at the header/address level and leave their remaining bytes in `unparsed`.
+
+The parser validates bounds before every read, rejects trailing bytes when parsing a single frame, and does not perform socket or stream I/O.
+
+## Development
+
+```text
+python -m pip install pytest build
+python -m pytest
+python -m build
+```

iec60870_parser-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "iec60870-parser"
+version = "0.1.0"
+description = "Zero-dependency IEC 60870-5-101/103/104 frame parser"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "IEC 60870 Parser Contributors" }]
+keywords = ["iec60870", "scada", "telemetry", "industrial", "protocol"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: System :: Networking",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

iec60870_parser-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

iec60870_parser-0.1.0/src/iec60870/__init__.py

@@ -0,0 +1,11 @@
+"""IEC 60870-5 frame parsing primitives."""
+
+from .parser import (
+    FrameStatus,
+    ParseResult,
+    T104Session,
+    parse_asdu,
+    parse_frame,
+)
+
+__all__ = ["FrameStatus", "ParseResult", "T104Session", "parse_asdu", "parse_frame"]

iec60870_parser-0.1.0/src/iec60870/parser.py

@@ -0,0 +1,246 @@
+"""Bounded, allocation-conscious parsers for IEC 60870-5 FT1.2 and APCI.
+
+The parser never raises for malformed wire data. It returns INCOMPLETE when more
+bytes may make a frame valid and CORRUPTED when the bytes contradict the format.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, Optional, Sequence, Tuple
+
+
+class FrameStatus(str, Enum):
+    VALID = "VALID"
+    INCOMPLETE = "INCOMPLETE"
+    CORRUPTED = "CORRUPTED"
+
+
+@dataclass(frozen=True)
+class ParseResult:
+    status: FrameStatus
+    protocol: str
+    frame_length: Optional[int] = None
+    frame_type: Optional[str] = None
+    fields: Dict[str, Any] = field(default_factory=dict)
+    error: Optional[str] = None
+
+
+@dataclass
+class T104Session:
+    """Optional APCI sequence state for a TCP connection."""
+
+    next_receive_sequence: int = 0
+    next_send_sequence: int = 0
+
+    def parse(self, data: bytes, *, parse_asdu_data: bool = True) -> ParseResult:
+        result = parse_frame(
+            data,
+            protocol="t104",
+            expected_receive_sequence=self.next_receive_sequence,
+            parse_asdu_data=parse_asdu_data,
+        )
+        if result.status is FrameStatus.VALID and result.frame_type == "I":
+            self.next_receive_sequence = (result.fields["receive_sequence"] + 1) & 0x7FFF
+        return result
+
+
+def _u16le(data: Sequence[int], offset: int) -> int:
+    return data[offset] | (data[offset + 1] << 8)
+
+
+def _u24le(data: Sequence[int], offset: int) -> int:
+    return data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16)
+
+
+def _result(status: FrameStatus, protocol: str, **kwargs: Any) -> ParseResult:
+    return ParseResult(status=status, protocol=protocol, **kwargs)
+
+
+def _parse_ft12(
+    data: bytes,
+    protocol: str,
+    *,
+    link_address_size: int,
+    parse_asdu_data: bool,
+) -> ParseResult:
+    if not data:
+        return _result(FrameStatus.INCOMPLETE, protocol, error="empty buffer")
+    if data[0] == 0x10:
+        if len(data) < 5:
+            return _result(FrameStatus.INCOMPLETE, protocol, frame_type="fixed")
+        if data[4] != 0x16:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type="fixed", error="bad fixed-frame stop")
+        checksum = sum(data[1:3]) & 0xFF
+        if checksum != data[3]:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type="fixed", error="checksum mismatch")
+        if len(data) > 5:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type="fixed", error="trailing bytes")
+        return _result(
+            FrameStatus.VALID,
+            protocol,
+            frame_length=5,
+            frame_type="fixed",
+            fields={"control": data[1], "link_address": data[2], "checksum": data[3]},
+        )
+    if data[0] != 0x68:
+        return _result(FrameStatus.CORRUPTED, protocol, error="unknown FT1.2 start")
+    if len(data) < 4:
+        return _result(FrameStatus.INCOMPLETE, protocol, frame_type="variable")
+    length = data[1]
+    if data[2] != length or data[3] != 0x68:
+        return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error="length/start repetition mismatch")
+    total = length + 6
+    if length < 1 + link_address_size:
+        return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error="length excludes control/address")
+    if len(data) < total:
+        return _result(FrameStatus.INCOMPLETE, protocol, frame_type="variable", frame_length=total)
+    if len(data) > total:
+        return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error="trailing bytes")
+    if data[total - 1] != 0x16:
+        return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error="bad variable-frame stop")
+    body_start = 4
+    checksum_offset = 4 + length
+    if (sum(data[body_start:checksum_offset]) & 0xFF) != data[checksum_offset]:
+        return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error="checksum mismatch")
+    control = data[body_start]
+    address = int.from_bytes(data[body_start + 1:body_start + 1 + link_address_size], "little")
+    asdu_start = body_start + 1 + link_address_size
+    fields: Dict[str, Any] = {
+        "control": control,
+        "link_address": address,
+        "checksum": data[checksum_offset],
+    }
+    if parse_asdu_data and asdu_start < checksum_offset:
+        asdu = parse_asdu(data[asdu_start:checksum_offset])
+        if asdu["status"] != FrameStatus.VALID.value:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type="variable", error=asdu["error"])
+        fields["asdu"] = asdu
+    return _result(FrameStatus.VALID, protocol, frame_length=total, frame_type="variable", fields=fields)
+
+
+def _parse_t104(
+    data: bytes,
+    *,
+    expected_receive_sequence: Optional[int],
+    parse_asdu_data: bool,
+) -> ParseResult:
+    protocol = "t104"
+    if not data:
+        return _result(FrameStatus.INCOMPLETE, protocol, error="empty buffer")
+    if data[0] != 0x68:
+        return _result(FrameStatus.CORRUPTED, protocol, error="missing APCI start")
+    if len(data) < 2:
+        return _result(FrameStatus.INCOMPLETE, protocol)
+    apdu_length = data[1]
+    if apdu_length < 4:
+        return _result(FrameStatus.CORRUPTED, protocol, error="APCI length is below four control bytes")
+    total = apdu_length + 2
+    if len(data) < total:
+        return _result(FrameStatus.INCOMPLETE, protocol, frame_length=total)
+    if len(data) > total:
+        return _result(FrameStatus.CORRUPTED, protocol, error="multiple APDUs or trailing bytes")
+    control = data[2:6]
+    if (control[0] & 1) == 0:
+        frame_type = "I"
+        send_sequence = ((control[1] << 8) | control[0]) >> 1
+        receive_sequence = ((control[3] << 8) | control[2]) >> 1
+        if expected_receive_sequence is not None and receive_sequence != expected_receive_sequence:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type=frame_type, error="receive sequence mismatch")
+        fields: Dict[str, Any] = {"send_sequence": send_sequence, "receive_sequence": receive_sequence}
+        asdu_start = 6
+    elif (control[0] & 3) == 1:
+        frame_type = "S"
+        receive_sequence = ((control[3] << 8) | control[2]) >> 1
+        fields = {"receive_sequence": receive_sequence}
+        asdu_start = total
+    else:
+        frame_type = "U"
+        code = control[0] & 0xFC
+        u_names = {0x04: "STARTDT act", 0x08: "STARTDT con", 0x10: "STOPDT act", 0x20: "STOPDT con", 0x40: "TESTFR act", 0x80: "TESTFR con"}
+        fields = {"u_function": u_names.get(code, "UNKNOWN"), "u_code": code}
+        asdu_start = total
+    if parse_asdu_data and frame_type == "I":
+        asdu = parse_asdu(data[asdu_start:total])
+        if asdu["status"] != FrameStatus.VALID.value:
+            return _result(FrameStatus.CORRUPTED, protocol, frame_type=frame_type, error=asdu["error"])
+        fields["asdu"] = asdu
+    return _result(FrameStatus.VALID, protocol, frame_length=total, frame_type=frame_type, fields=fields)
+
+
+def parse_frame(
+    data: bytes,
+    *,
+    protocol: str = "auto",
+    link_address_size: Optional[int] = None,
+    expected_receive_sequence: Optional[int] = None,
+    parse_asdu_data: bool = True,
+) -> ParseResult:
+    """Parse exactly one frame from a bytes-like buffer.
+
+    ``protocol`` is ``"t101"``, ``"t103"``, ``"t104"``, or ``"auto"``.
+    Auto mode distinguishes FT1.2 by its repeated 0x68 marker; explicit mode is
+    recommended when an incomplete buffer contains fewer than four bytes.
+    """
+    try:
+        raw = bytes(data)
+    except (TypeError, ValueError):
+        return _result(FrameStatus.CORRUPTED, protocol, error="data must be bytes-like")
+    selected = protocol.lower()
+    if selected not in {"auto", "t101", "t103", "t104"}:
+        return _result(FrameStatus.CORRUPTED, selected, error="unsupported protocol")
+    if selected == "auto":
+        if len(raw) >= 4 and raw[0] == 0x68 and raw[3] == 0x68:
+            selected = "t101"
+        elif raw and raw[0] in (0x10,):
+            selected = "t101"
+        elif raw and raw[0] == 0x68:
+            selected = "t104"
+        else:
+            selected = "t101"
+    if selected in {"t101", "t103"}:
+        address_size = link_address_size if link_address_size is not None else (1 if selected == "t101" else 2)
+        if address_size not in (1, 2):
+            return _result(FrameStatus.CORRUPTED, selected, error="link_address_size must be 1 or 2")
+        return _parse_ft12(raw, selected, link_address_size=address_size, parse_asdu_data=parse_asdu_data)
+    return _parse_t104(raw, expected_receive_sequence=expected_receive_sequence, parse_asdu_data=parse_asdu_data)
+
+
+def parse_asdu(data: bytes, *, ioa_size: int = 3, cot_size: int = 2, coa_size: int = 2) -> Dict[str, Any]:
+    """Decode the common ASDU header and known Type 1 and Type 30 objects."""
+    raw = bytes(data)
+    if ioa_size not in (1, 2, 3) or cot_size not in (1, 2) or coa_size not in (1, 2):
+        return {"status": FrameStatus.CORRUPTED.value, "error": "unsupported ASDU address width"}
+    header_size = 2 + cot_size + coa_size
+    if len(raw) < header_size:
+        return {"status": FrameStatus.INCOMPLETE.value, "error": "short ASDU header"}
+    type_id = raw[0]
+    vsq = raw[1]
+    count = vsq & 0x7F
+    sequence = bool(vsq & 0x80)
+    cot = int.from_bytes(raw[2:2 + cot_size], "little")
+    coa_start = 2 + cot_size
+    common_address = int.from_bytes(raw[coa_start:coa_start + coa_size], "little")
+    offset = header_size
+    objects = []
+    value_size = 1 + (7 if type_id == 30 else 0)
+    if type_id not in (1, 30):
+        value_size = 0
+    for index in range(count):
+        if not sequence or index == 0:
+            if offset + ioa_size > len(raw):
+                return {"status": FrameStatus.INCOMPLETE.value, "error": "short information object address"}
+            ioa = int.from_bytes(raw[offset:offset + ioa_size], "little")
+            offset += ioa_size
+        else:
+            ioa += 1
+        item: Dict[str, Any] = {"ioa": ioa}
+        if value_size:
+            if offset + value_size > len(raw):
+                return {"status": FrameStatus.INCOMPLETE.value, "error": "short information object value"}
+            item["value"] = raw[offset]
+            offset += 1
+            if type_id == 30:
+                item["cp56time2a"] = raw[offset:offset + 7]
+                offset += 7
+        objects.append(item)
+    return {"status": FrameStatus.VALID.value, "type_id": type_id, "vsq": vsq, "count": count, "sequence": sequence, "cot": cot, "common_address": common_address, "information_objects": objects, "unparsed": raw[offset:]}

iec60870_parser-0.1.0/src/iec60870_parser.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: iec60870-parser
+Version: 0.1.0
+Summary: Zero-dependency IEC 60870-5-101/103/104 frame parser
+Author: IEC 60870 Parser Contributors
+License: MIT
+Keywords: iec60870,scada,telemetry,industrial,protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# iec60870-parser
+
+A pure-Python, zero-runtime-dependency parser and validator for IEC 60870-5-101, -103, and -104 telemetry frames. It consumes one raw byte buffer at a time and returns a structured `ParseResult` with `VALID`, `INCOMPLETE`, or `CORRUPTED` status.
+
+## Install
+
+```text
+python -m pip install iec60870-parser
+```
+
+For a source checkout:
+
+```text
+python -m pip install -e .
+```
+
+## API
+
+```python
+from iec60870 import FrameStatus, T104Session, parse_frame
+
+result = parse_frame(raw_bytes, protocol="t104")
+if result.status is FrameStatus.VALID:
+    print(result.frame_type, result.fields)
+elif result.status is FrameStatus.INCOMPLETE:
+    # Retain the buffer and read more bytes.
+    pass
+else:
+    print(result.error)
+```
+
+`protocol` accepts `t101`, `t103`, `t104`, or `auto`. Explicit protocol selection is preferred for short/incomplete buffers. T101 uses a one-byte link address by default; T103 uses two bytes. Override either with `link_address_size=1` or `2`.
+
+For a stream connection, `T104Session` checks the receive sequence number of I-format APDUs and advances it after each valid telemetry frame:
+
+```python
+session = T104Session()
+result = session.parse(apdu_bytes)
+```
+
+## Wire formats
+
+### T101 and T103 FT1.2
+
+Variable frames are `68 L L 68 [control] [link address] [ASDU] [CS] 16`. `L` is the number of bytes from control through ASDU, and `CS` is the sum of those bytes modulo 256. Fixed frames are `10 [control] [link address] [CS] 16`; the fixed-frame helper uses the one-byte control/address layout defined by this package API.
+
+T103 uses the same FT1.2 framing and checksum but defaults to a two-byte link address. Companion-standard ASDU variations that are not Type 1 or Type 30 remain available through raw frame fields and can be decoded with `parse_asdu` using the relevant address widths.
+
+### T104 APCI
+
+An APDU is `68 L [four APCI control bytes] [ASDU]`. I-format control fields expose `send_sequence` and `receive_sequence`; S-format exposes the receive sequence; U-format exposes `STARTDT`, `STOPDT`, and `TESTFR` activation/confirmation names. APCI integers are decoded in little-endian wire order and sequence values are 15-bit values.
+
+## ASDU schema
+
+`parse_asdu` returns a dictionary containing `type_id`, `vsq`, `count`, `sequence`, `cot`, `common_address`, and `information_objects`. Type 1 objects decode a one-byte single-point value. Type 30 objects decode the one-byte value plus the seven raw CP56Time2a bytes. Unknown type identifiers are validated at the header/address level and leave their remaining bytes in `unparsed`.
+
+The parser validates bounds before every read, rejects trailing bytes when parsing a single frame, and does not perform socket or stream I/O.
+
+## Development
+
+```text
+python -m pip install pytest build
+python -m pytest
+python -m build
+```

iec60870_parser-0.1.0/src/iec60870_parser.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/iec60870/__init__.py
+src/iec60870/parser.py
+src/iec60870_parser.egg-info/PKG-INFO
+src/iec60870_parser.egg-info/SOURCES.txt
+src/iec60870_parser.egg-info/dependency_links.txt
+src/iec60870_parser.egg-info/top_level.txt
+tests/test_parser.py

iec60870_parser-0.1.0/src/iec60870_parser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

iec60870_parser-0.1.0/src/iec60870_parser.egg-info/top_level.txt

@@ -0,0 +1 @@
+iec60870

iec60870_parser-0.1.0/tests/test_parser.py

@@ -0,0 +1,66 @@
+from iec60870 import FrameStatus, T104Session, parse_asdu, parse_frame
+
+
+def variable_frame(asdu: bytes, address: bytes = b"\x01") -> bytes:
+    body = b"\x00" + address + asdu
+    checksum = bytes([sum(body) & 0xFF])
+    return b"\x68" + bytes([len(body)]) * 2 + b"\x68" + body + checksum + b"\x16"
+
+
+def t104_i_frame(asdu: bytes, send: int = 0, receive: int = 0) -> bytes:
+    c0 = (send << 1) & 0xFF
+    c1 = (send >> 7) & 0xFF
+    c2 = (receive << 1) & 0xFF
+    c3 = (receive >> 7) & 0xFF
+    body = bytes([c0, c1, c2, c3]) + asdu
+    return b"\x68" + bytes([len(body)]) + body
+
+
+def single_point_asdu(ioa: int = 1) -> bytes:
+    return bytes([1, 1, 3, 0, 1, 0]) + ioa.to_bytes(3, "little") + b"\x01"
+
+
+def test_t101_variable_and_asdu():
+    result = parse_frame(variable_frame(single_point_asdu()), protocol="t101")
+    assert result.status is FrameStatus.VALID
+    assert result.fields["asdu"]["type_id"] == 1
+    assert result.fields["asdu"]["information_objects"][0]["ioa"] == 1
+
+
+def test_t101_checksum_corruption():
+    frame = bytearray(variable_frame(single_point_asdu()))
+    frame[-2] ^= 0x01
+    assert parse_frame(frame, protocol="t101").status is FrameStatus.CORRUPTED
+
+
+def test_fixed_frame_and_short_frame():
+    assert parse_frame(b"\x10\x00\x01\x01\x16", protocol="t101").status is FrameStatus.VALID
+    assert parse_frame(b"\x68\x04\x04", protocol="t101").status is FrameStatus.INCOMPLETE
+
+
+def test_t103_two_byte_link_address():
+    result = parse_frame(variable_frame(single_point_asdu(), b"\x34\x12"), protocol="t103")
+    assert result.status is FrameStatus.VALID
+    assert result.fields["link_address"] == 0x1234
+
+
+def test_t104_i_sequence_and_session():
+    session = T104Session()
+    result = session.parse(t104_i_frame(single_point_asdu()))
+    assert result.status is FrameStatus.VALID
+    assert session.next_receive_sequence == 1
+    assert parse_frame(t104_i_frame(single_point_asdu(), receive=3), protocol="t104", expected_receive_sequence=0).status is FrameStatus.CORRUPTED
+
+
+def test_t104_s_and_u_formats():
+    assert parse_frame(b"\x68\x04\x01\x00\x00\x00", protocol="t104").frame_type == "S"
+    assert parse_frame(b"\x68\x04\x07\x00\x00\x00", protocol="t104").fields["u_function"] == "STARTDT act"
+    assert parse_frame(b"\x68\x04\x13\x00\x00\x00", protocol="t104").fields["u_function"] == "STOPDT act"
+
+
+def test_type_30_sequence_objects():
+    header = bytes([30, 0x82, 3, 0, 1, 0])
+    data = header + (10).to_bytes(3, "little") + b"\x01" + bytes(7) + b"\x00" + bytes(7)
+    result = parse_asdu(data)
+    assert result["status"] == "VALID"
+    assert [item["ioa"] for item in result["information_objects"]] == [10, 11]