aioads 0.1.0.dev3__tar.gz → 0.1.0.dev4__tar.gz

aioads-0.1.0.dev4/.github/dependabot.yml

@@ -0,0 +1,20 @@
+version: 2
+updates:
+  # Keep the SHA-pinned GitHub Actions current (Dependabot updates both the
+  # pinned SHA and the trailing version comment).
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    groups:
+      actions:
+        patterns: ["*"]
+
+  # Python dev/runtime dependencies tracked in pdm.lock / pyproject.toml.
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: weekly
+    groups:
+      python:
+        patterns: ["*"]

aioads-0.1.0.dev4/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up PDM
+        uses: pdm-project/setup-pdm@973541a5febeafcfdadf8a51211435be6ecfd90f  # v4.5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: true
+
+      - name: Install dependencies
+        run: pdm install
+
+      - name: Lint
+        run: pdm run lint
+
+      - name: Run tests with coverage
+        run: pdm run coverage
+
+      - name: Upload coverage artifact
+        if: matrix.python-version == '3.12'
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: coverage-xml
+          path: coverage.xml
+          if-no-files-found: ignore

aioads-0.1.0.dev4/.github/workflows/publish.yml

@@ -0,0 +1,62 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+# Avoid two releases racing to publish the same version.
+concurrency:
+  group: publish-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd  # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up PDM
+        uses: pdm-project/setup-pdm@973541a5febeafcfdadf8a51211435be6ecfd90f  # v4.5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: pdm build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    # Only publish for real releases, not manual test runs.
+    if: github.event_name == 'release'
+    environment:
+      name: pypi
+      url: https://pypi.org/project/aioads/
+    permissions:
+      # IMPORTANT: required for OIDC trusted publishing.
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b  # v1.14.0
+        with:
+          # Sign the published distributions with PEP 740 build provenance.
+          attestations: true

{aioads-0.1.0.dev3 → aioads-0.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioads
-Version: 0.1.0.dev3
+Version: 0.1.0.dev4
 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.dev3 → aioads-0.1.0.dev4}/aioads/ads_client.py

@@ -266,36 +266,59 @@ class AdsClient:
     ) -> dict[str, SymbolReadResult]:
         """
         Read multiple symbols by their names from the ADS device.
+
+        The returned dict is keyed by the symbol names exactly as requested,
+        preserving their original casing.
         """
         symbol_infos = await self._cache.read_symbol_infos_by_names(symbol_names)
         if raise_errors:
             self._raise_if_error(symbol_infos)
 
-        read_commands = [
-            AdsReadCommand(
-                transport=self.transport,
-                ams_address=self.dst_address,
-                idx_group=symbol_info.idx_group,
-                idx_offset=symbol_info.idx_offset,
-                length=symbol_info.idx_length,
-            )
-            for _, symbol_info in symbol_infos.values()
-        ]
+        output: dict[str, SymbolReadResult] = {}
+
+        # Only symbols whose info resolved successfully can be read. Symbols
+        # with a lookup error are reported as-is; building a read command from
+        # their (invalid) index group/offset would misalign the bulk response.
+        readable: list[tuple[str, SymbolInfo]] = []
+        for requested_name, (error_code, symbol_info) in symbol_infos.items():
+            if not error_code.ok:
+                output[requested_name] = SymbolReadResult(error_code, None)
+            else:
+                readable.append((requested_name, symbol_info))
+
+        if not readable:
+            return output
+
         function = AdsSumRead(
             transport=self.transport,
             ams_address=self.dst_address,
-            commands=read_commands,
+            commands=[
+                AdsReadCommand(
+                    transport=self.transport,
+                    ams_address=self.dst_address,
+                    idx_group=symbol_info.idx_group,
+                    idx_offset=symbol_info.idx_offset,
+                    length=symbol_info.idx_length,
+                )
+                for _, symbol_info in readable
+            ],
         )
-
         response = await function.execute()
-        output: dict[str, SymbolReadResult] = {}
 
+        loop = asyncio.get_running_loop()
+        parse_names: list[str] = []
         tasks = []
-        for (_, resp_payload), (error_code, symbol_info) in zip(
-            response, symbol_infos.values()
+        for (requested_name, symbol_info), (read_response, resp_payload) in zip(
+            readable, response
         ):
+            # A failed read yields no usable payload, so skip parsing it.
+            if read_response.error_code != 0:
+                output[requested_name] = SymbolReadResult(
+                    read_response.error_code, None)
+                continue
+            parse_names.append(requested_name)
             tasks.append(
-                asyncio.get_running_loop().run_in_executor(
+                loop.run_in_executor(
                     self.parser_pool,
                     self.parser.parse,
                     symbol_info.data_type,
@@ -303,11 +326,11 @@ class AdsClient:
                     resp_payload,
                 )
             )
-        parsed = await asyncio.gather(*tasks)
 
-        for symbol_data, (error_code, symbol_info) in zip(parsed, symbol_infos.values()):
-            output[symbol_info.symbol_name] = SymbolReadResult(
-                error_code, symbol_data)
+        parsed = await asyncio.gather(*tasks)
+        for requested_name, symbol_data in zip(parse_names, parsed):
+            output[requested_name] = SymbolReadResult(
+                AdsErrorCode(0), symbol_data)
 
         return output
 

{aioads-0.1.0.dev3 → aioads-0.1.0.dev4}/aioads/commands/ads_add_notification.py

@@ -77,7 +77,7 @@ class AdsAddNotificationCommand(ICommand[AdsAddNotificationResponse]):
     Ads command to create a ads notification (subscription to a remote resource)
     """
 
-    SERIALIZE_STRUCT_DEF: Final[Struct] = Struct("<IIIIIII16s")
+    SERIALIZE_STRUCT_DEF: Final[Struct] = Struct("<IIIIII16s")
 
     def __init__(
         self,

{aioads-0.1.0.dev3 → aioads-0.1.0.dev4}/aioads/commands/errors.py

@@ -27,4 +27,7 @@ class AdsCommandError(Exception):
 
     def __repr__(self) -> str:
         """Returns a detailed representation of the error for debugging."""
-        return f"AdsCommandError(error_code={self.error_code!r}, error_message:{self.error_code.description} args={self.args!r})"
+        return (
+            f"AdsCommandError(error_code={self.error_code!r}, "
+            f"error_message:{self.error_code.description} args={self.args!r})"
+        )

{aioads-0.1.0.dev3 → aioads-0.1.0.dev4}/aioads/transport.py

@@ -364,7 +364,8 @@ class AdsTcpTransport(BaseTransport, ITransport):
         while self._state is not ConnectionState.CLOSED:
             try:
                 await self._read_loop()
-            except asyncio.CancelledError:
+            except asyncio.CancelledError: #pylint: disable=try-except-raise
+                # Except everything... except a cancellation event
                 raise
             except Exception as e:
                 self.logger.info("Connection lost: %s", e)
@@ -381,7 +382,7 @@ class AdsTcpTransport(BaseTransport, ITransport):
                     self.logger.info("Reconnected to the remote")
                     backoff = self.RECONNECT_INITIAL_BACKOFF
                     break
-                except asyncio.CancelledError:
+                except asyncio.CancelledError: #pylint: disable=try-except-raise
                     raise
                 except Exception as e:  # pylint: disable=broad-exception-caught
                     self.logger.info(
@@ -401,10 +402,23 @@ class AdsTcpTransport(BaseTransport, ITransport):
 
         reader, _ = stream
         while True:
-            # Read AmsTcpHeader
-            tcp_header_bytes = await reader.readexactly(AmsTcpHeader.FIXED_SIZE)
-            tcp_header = AmsTcpHeader.deserialize(tcp_header_bytes)
-            payload_bytes = await reader.readexactly(tcp_header.length)
+            try:
+                # Read AmsTcpHeader
+                tcp_header_bytes = await reader.readexactly(AmsTcpHeader.FIXED_SIZE)
+                tcp_header = AmsTcpHeader.deserialize(tcp_header_bytes)
+                payload_bytes = await reader.readexactly(tcp_header.length)
+            except asyncio.IncompleteReadError as e:
+                # readexactly hit EOF: the peer's recv() returned 0 bytes,
+                # i.e. the remote closed the connection. An empty partial is an
+                # orderly close on a message boundary; a non-empty partial means
+                # we were cut off mid-message. Either way the stream is dead, so
+                # raise a clear ConnectionError for the supervisor to reconnect.
+                if e.partial:
+                    raise ConnectionError(
+                        f"Connection closed mid-message: received "
+                        f"{len(e.partial)} of {e.expected} expected bytes"
+                    ) from e
+                raise ConnectionError("Connection closed by remote") from e
 
             ams_message_stream = AdsStream(memoryview(payload_bytes))
             ams_header = AmsHeader.deserialize(ams_message_stream)
@@ -459,6 +473,7 @@ class AdsOverMqttTopics:
 
 
 class MqttBaseTransport(BaseTransport):
+    """Base transport that tunnels AMS/ADS frames over an MQTT broker."""
 
     REQUEST_TIMEOUT = 120.0
 
@@ -771,7 +786,7 @@ class AdsGMqttTransport(MqttBaseTransport, ITransport):
                 response_future, timeout=self.REQUEST_TIMEOUT
             )
 
-    async def _on_response(self, _client: gmqtt.Client, topic: str, payload: bytes, qos: int, properties: dict):
+    async def _on_response(self, _client: gmqtt.Client, topic: str, payload: bytes, _qos: int, _properties: dict):
         if self.topics.matches(self.topics.sub_response, topic):
             ams_message_stream = AdsStream(memoryview(payload))
             ams_header = AmsHeader.deserialize(ams_message_stream)