aioads 0.1.0.dev8__tar.gz → 0.1.0.dev9__tar.gz

{aioads-0.1.0.dev8 → aioads-0.1.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioads
-Version: 0.1.0.dev8
+Version: 0.1.0.dev9
 Summary: An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs
 Author-email: MkKiefer <102972583+MkKiefer@users.noreply.github.com>
 License: MIT

{aioads-0.1.0.dev8 → aioads-0.1.0.dev9}/aioads/ads_symbol_parser.py

@@ -134,6 +134,37 @@ class AdsSymbolParser(ISymbolParser):
 
     def __init__(self, data_types: list[SymbolDataTypeResponse]):
         self._type_lookup = {dt.name: dt for dt in data_types}
+        # Resolution of IEC 61131-3 elementary type names to their wire encoding.
+        self._elementary_type_names: dict[str, AdsSymbolDataType] = {
+            "BOOL": AdsSymbolDataType.BIT,
+            "BIT": AdsSymbolDataType.BIT,
+            "SINT": AdsSymbolDataType.INT8,
+            "USINT": AdsSymbolDataType.UINT8,
+            "BYTE": AdsSymbolDataType.UINT8,
+            "INT": AdsSymbolDataType.INT16,
+            "UINT": AdsSymbolDataType.UINT16,
+            "WORD": AdsSymbolDataType.UINT16,
+            "DINT": AdsSymbolDataType.INT32,
+            "UDINT": AdsSymbolDataType.UINT32,
+            "DWORD": AdsSymbolDataType.UINT32,
+            "LINT": AdsSymbolDataType.INT64,
+            "ULINT": AdsSymbolDataType.UINT64,
+            "LWORD": AdsSymbolDataType.UINT64,
+            "REAL": AdsSymbolDataType.REAL32,
+            "LREAL": AdsSymbolDataType.REAL64,
+            "TIME": AdsSymbolDataType.UINT32,
+            "TOD": AdsSymbolDataType.UINT32,
+            "TIME_OF_DAY": AdsSymbolDataType.UINT32,
+            "DATE": AdsSymbolDataType.UINT32,
+            "DT": AdsSymbolDataType.UINT32,
+            "DATE_AND_TIME": AdsSymbolDataType.UINT32,
+            "LTIME": AdsSymbolDataType.UINT64,
+            "LTOD": AdsSymbolDataType.UINT64,
+            "LTIME_OF_DAY": AdsSymbolDataType.UINT64,
+            "LDATE": AdsSymbolDataType.UINT64,
+            "LDT": AdsSymbolDataType.UINT64,
+            "LDATE_AND_TIME": AdsSymbolDataType.UINT64,
+        }
         self._const_type_names: dict[str, Callable[[str, AdsStream], Any]] = {
             "Tc2_System.T_MaxString": lambda type_name, raw_data: raw_data.read(255)
             .decode("latin-1")
@@ -142,6 +173,7 @@ class AdsSymbolParser(ISymbolParser):
             .decode("latin-1")
             .rstrip("\x00"),
         }
+
         self._primitive_parser = PrimitiveTypeParser()
 
     def update_datatypes(self, data_types: list[SymbolDataTypeResponse]) -> None:
@@ -265,6 +297,13 @@ class AdsSymbolParser(ISymbolParser):
         if data_type != AdsSymbolDataType.BIGTYPE:
             return self._primitive_parser.parse(data_type, type_name, raw_data)
 
+        # TwinCAT 2 reports BIGTYPE for some elementary types
+        # like INT, UINT, REAL, etc. So we need to resolve them by name.
+        if type_name in self._elementary_type_names:
+            return self._primitive_parser.parse(
+                self._elementary_type_names[type_name], type_name, raw_data
+            )
+
         # Parsing of structured types
         if data_type == AdsSymbolDataType.BIGTYPE:
             return self.parse_struct(type_name, raw_data)

{aioads-0.1.0.dev8 → aioads-0.1.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioads"
-version = "0.1.0.dev8"
+version = "0.1.0.dev9"
 description = "An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs"
 authors = [
     { name = "MkKiefer", email = "102972583+MkKiefer@users.noreply.github.com" },
@@ -78,4 +78,5 @@ disable = [
     "too-many-locals",
     "too-few-public-methods",
     "broad-exception-caught",
+    "too-many-return-statements",
 ]

{aioads-0.1.0.dev8 → aioads-0.1.0.dev9}/tests/unit/test_ads_symbol_parser.py

@@ -3,6 +3,8 @@
 import struct
 import unittest
 
+from parameterized import parameterized
+
 from aioads.ads_symbol_parser import AdsSymbolParser, PrimitiveTypeParser
 from aioads.functions.ads_symbol_datatype_by_name import SymbolDataTypeResponse
 from aioads.functions.ads_symbol_info_by_name_ex import (
@@ -89,7 +91,8 @@ class TestPrimitiveTypeParser(unittest.TestCase):
         stream = make_stream(b"Hi\x00\x00\x00\x00")
 
         # Act
-        result = self.parser.parse(AdsSymbolDataType.STRING, "STRING(5)", stream)
+        result = self.parser.parse(
+            AdsSymbolDataType.STRING, "STRING(5)", stream)
 
         # Assert
         self.assertEqual(result, "Hi")
@@ -110,7 +113,8 @@ class TestPrimitiveTypeParser(unittest.TestCase):
         stream = make_stream(raw)
 
         # Act
-        result = self.parser.parse(AdsSymbolDataType.WSTRING, "WSTRING(3)", stream)
+        result = self.parser.parse(
+            AdsSymbolDataType.WSTRING, "WSTRING(3)", stream)
 
         # Assert
         self.assertEqual(result, "Hi")
@@ -136,7 +140,8 @@ class TestAdsSymbolParser(unittest.TestCase):
         stream = make_stream(bytes(range(8)))
 
         # Act
-        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "REFERENCE TO ST_Foo", stream)
+        result = self.parser.parse(
+            AdsSymbolDataType.BIGTYPE, "REFERENCE TO ST_Foo", stream)
 
         # Assert
         self.assertEqual(result, "0001020304050607^")
@@ -146,7 +151,8 @@ class TestAdsSymbolParser(unittest.TestCase):
         stream = make_stream(bytes(range(8)))
 
         # Act
-        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "POINTER TO ST_Foo", stream)
+        result = self.parser.parse(
+            AdsSymbolDataType.BIGTYPE, "POINTER TO ST_Foo", stream)
 
         # Assert
         self.assertEqual(result, "0001020304050607*")
@@ -181,7 +187,8 @@ class TestAdsSymbolParser(unittest.TestCase):
 
         # Act / Assert
         with self.assertRaises(ValueError) as ctx:
-            self.parser.parse(AdsSymbolDataType.INT16, "ARRAY OF nonsense", stream)
+            self.parser.parse(AdsSymbolDataType.INT16,
+                              "ARRAY OF nonsense", stream)
 
         self.assertIn("Cannot parse array type", str(ctx.exception))
 
@@ -200,14 +207,18 @@ class TestAdsSymbolParser(unittest.TestCase):
 
     def test_parse_struct_with_sub_items_returns_dict(self) -> None:
         # Arrange
-        sub_a = make_datatype("a", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16", offs=0)
-        sub_b = make_datatype("b", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16", offs=2)
-        struct_type = make_datatype("ST_Pair", size=4, sub_items=[sub_a, sub_b])
+        sub_a = make_datatype(
+            "a", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16", offs=0)
+        sub_b = make_datatype(
+            "b", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16", offs=2)
+        struct_type = make_datatype(
+            "ST_Pair", size=4, sub_items=[sub_a, sub_b])
         self.parser.update_datatypes([struct_type])
         stream = make_stream(struct.pack("<hh", 10, 20))
 
         # Act
-        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "ST_Pair", stream)
+        result = self.parser.parse(
+            AdsSymbolDataType.BIGTYPE, "ST_Pair", stream)
 
         # Assert
         self.assertEqual(result, {"a": 10, "b": 20})
@@ -222,18 +233,151 @@ class TestAdsSymbolParser(unittest.TestCase):
 
         self.assertIn("unknown type name", str(ctx.exception))
 
+    @parameterized.expand([
+        ("BOOL", b"\x01", True),
+        ("INT", struct.pack("<h", -7), -7),
+        ("WORD", struct.pack("<H", 512), 512),
+        ("DINT", struct.pack("<i", -100_000), -100_000),
+        ("LWORD", struct.pack("<Q", 2**40), 2**40),
+        ("LREAL", struct.pack("<d", 2.5), 2.5),
+    ])
+    def test_parse_bigtype_with_elementary_name_resolves_by_name(
+        self, type_name: str, raw: bytes, expected: object
+    ) -> None:
+        """TwinCAT 2 reports BIGTYPE even for elementary types like INT."""
+        # Arrange
+        stream = make_stream(raw)
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, type_name, stream)
+
+        # Assert
+        self.assertEqual(result, expected)
+
+    def test_parse_time_returns_milliseconds(self) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<I", 90_500))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "TIME", stream)
+
+        # Assert
+        self.assertEqual(result, 90_500)
+
+    def test_parse_ltime_returns_nanoseconds(self) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<Q", 1_500_000_000))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "LTIME", stream)
+
+        # Assert
+        self.assertEqual(result, 1_500_000_000)
+
+    def test_parse_time_of_day_returns_milliseconds_since_midnight(self) -> None:
+        # Arrange
+        milliseconds_since_midnight = (13 * 3600 + 37 * 60 + 5) * 1000 + 250
+        stream = make_stream(struct.pack("<I", milliseconds_since_midnight))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "TOD", stream)
+
+        # Assert
+        self.assertEqual(result, milliseconds_since_midnight)
+
+    def test_parse_date_returns_epoch_seconds(self) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<I", 1_752_364_800))  # 2025-07-13
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "DATE", stream)
+
+        # Assert
+        self.assertEqual(result, 1_752_364_800)
+
+    def test_parse_date_and_time_returns_epoch_seconds(self) -> None:
+        # Arrange
+        # 2025-07-13T11:45:06Z
+        stream = make_stream(struct.pack("<I", 1_752_407_106))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, "DT", stream)
+
+        # Assert
+        self.assertEqual(result, 1_752_407_106)
+
+    @parameterized.expand([
+        ("LTIME",),
+        ("LTOD",),
+        ("LTIME_OF_DAY",),
+        ("LDATE",),
+        ("LDT",),
+        ("LDATE_AND_TIME",),
+    ])
+    def test_parse_long_datetime_types_return_nanoseconds(self, type_name: str) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<Q", 1_752_407_106_000_000_000))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, type_name, stream)
+
+        # Assert
+        self.assertEqual(result, 1_752_407_106_000_000_000)
+
+    @parameterized.expand([
+        ("TIME_OF_DAY",),
+        ("DATE_AND_TIME",),
+    ])
+    def test_parse_long_form_datetime_aliases_return_integer(self, type_name: str) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<I", 42_000))
+
+        # Act
+        result = self.parser.parse(AdsSymbolDataType.BIGTYPE, type_name, stream)
+
+        # Assert
+        self.assertEqual(result, 42_000)
+
+    def test_parse_array_of_time_returns_millisecond_list(self) -> None:
+        # Arrange
+        stream = make_stream(struct.pack("<II", 1000, 2000))
+
+        # Act
+        result = self.parser.parse(
+            AdsSymbolDataType.BIGTYPE, "ARRAY [0..1] OF TIME", stream
+        )
+
+        # Assert
+        self.assertEqual(result, [1000, 2000])
+
+    def test_parse_struct_with_time_sub_item_returns_millisecond_field(self) -> None:
+        # Arrange
+        sub_time = make_datatype("duration", size=4, type_name="TIME", offs=0)
+        struct_type = make_datatype("ST_Timed", size=4, sub_items=[sub_time])
+        self.parser.update_datatypes([struct_type])
+        stream = make_stream(struct.pack("<I", 250))
+
+        # Act
+        result = self.parser.parse(
+            AdsSymbolDataType.BIGTYPE, "ST_Timed", stream)
+
+        # Assert
+        self.assertEqual(result, {"duration": 250})
+
     def test_update_datatypes_registers_new_type_for_lookup(self) -> None:
         # Arrange
         struct_type = make_datatype(
             "ST_Single",
             size=2,
-            sub_items=[make_datatype("v", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16")],
+            sub_items=[make_datatype(
+                "v", size=2, data_type=AdsSymbolDataType.INT16, type_name="INT16")],
         )
 
         # Act
         self.parser.update_datatypes([struct_type])
         result = self.parser.parse(
-            AdsSymbolDataType.BIGTYPE, "ST_Single", make_stream(struct.pack("<h", 42))
+            AdsSymbolDataType.BIGTYPE, "ST_Single", make_stream(
+                struct.pack("<h", 42))
         )
 
         # Assert