slmp-connect-python 0.1.14__tar.gz → 0.1.15__tar.gz

{slmp_connect_python-0.1.14/slmp_connect_python.egg-info → slmp_connect_python-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slmp-connect-python
-Version: 0.1.14
+Version: 0.1.15
 Summary: SLMP Connect Python: client library for Mitsubishi SLMP binary communication
 Author: fa-yoshinobu
 License-Expression: MIT
@@ -43,6 +43,13 @@ Dynamic: license-file
 
 ![Illustration](https://raw.githubusercontent.com/fa-yoshinobu/plc-comm-slmp-python/main/docsrc/assets/melsec.png)
 
+[![Automated Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml)
+[![Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml)
+
+[![Python](https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![MkDocs](https://img.shields.io/badge/MkDocs-526CFE?logo=materialformkdocs&logoColor=white)](https://www.mkdocs.org/)
+[![GitHub Pages](https://img.shields.io/badge/GitHub%20Pages-222222?logo=githubpages&logoColor=white)](https://pages.github.com/)
+
 High-level SLMP helpers for Mitsubishi PLC communication over Binary 3E and 4E frames.
 
 This repository treats the high-level helper layer as the recommended user surface:

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/README.md

@@ -9,6 +9,13 @@
 
 ![Illustration](https://raw.githubusercontent.com/fa-yoshinobu/plc-comm-slmp-python/main/docsrc/assets/melsec.png)
 
+[![Automated Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml)
+[![Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml)
+
+[![Python](https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![MkDocs](https://img.shields.io/badge/MkDocs-526CFE?logo=materialformkdocs&logoColor=white)](https://www.mkdocs.org/)
+[![GitHub Pages](https://img.shields.io/badge/GitHub%20Pages-222222?logo=githubpages&logoColor=white)](https://pages.github.com/)
+
 High-level SLMP helpers for Mitsubishi PLC communication over Binary 3E and 4E frames.
 
 This repository treats the high-level helper layer as the recommended user surface:
@@ -16,11 +23,11 @@ This repository treats the high-level helper layer as the recommended user surfa
 - `SlmpConnectionOptions`
 - `open_and_connect` / `open_and_connect_sync`
 - `AsyncSlmpClient`
-- `QueuedAsyncSlmpClient`
-- `SlmpClient`
-- `normalize_address`
-- `parse_address` / `try_parse_address` / `format_address`
-- `read_typed` / `write_typed`
+- `QueuedAsyncSlmpClient`
+- `SlmpClient`
+- `normalize_address`
+- `parse_address` / `try_parse_address` / `format_address`
+- `read_typed` / `write_typed`
 - `read_words_single_request` / `read_dwords_single_request`
 - `read_words_chunked` / `read_dwords_chunked`
 - `write_bit_in_word`
@@ -148,17 +155,17 @@ Maintainer-only notes and retained evidence live under `internal_docs/`.
 
 ### Address Normalization
 
-```python
-from slmp import format_address, normalize_address, parse_address
-
-print(normalize_address("x20"))   # X20
-print(normalize_address("d200"))  # D200
-print(normalize_address("x100", plc_family="iq-f"))  # X100
-
-parsed = parse_address("d200:f")
-print(parsed.base_device, parsed.dtype)  # D200 F
-print(format_address(parsed))            # D200:F
-```
+```python
+from slmp import format_address, normalize_address, parse_address
+
+print(normalize_address("x20"))   # X20
+print(normalize_address("d200"))  # D200
+print(normalize_address("x100", plc_family="iq-f"))  # X100
+
+parsed = parse_address("d200:f")
+print(parsed.base_device, parsed.dtype)  # D200 F
+print(format_address(parsed))            # D200:F
+```
 
 ### Single Typed Values
 

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slmp-connect-python"
-version = "0.1.14"
+version = "0.1.15"
 description = "SLMP Connect Python: client library for Mitsubishi SLMP binary communication"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,8 +46,6 @@ dev = [
 
 [project.scripts]
 slmp-connection-check = "slmp.cli:connection_check_main"
-slmp-compatibility-probe = "slmp.cli:compatibility_probe_main"
-slmp-compatibility-matrix-render = "slmp.cli:compatibility_matrix_render_main"
 slmp-device-range-probe = "slmp.cli:device_range_probe_main"
 slmp-register-boundary-probe = "slmp.cli:register_boundary_probe_main"
 slmp-other-station-check = "slmp.cli:other_station_check_main"

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/slmp/cli.py

@@ -270,63 +270,6 @@ def _project_root() -> Path:
     return Path(__file__).resolve().parents[1]
 
 
-def _compatibility_default_output(*, plc_label: str, filename: str) -> str:
-    return _default_report_output(series="compatibility", model=plc_label, filename=filename)
-
-
-def _compatibility_selected_specs(
-    *,
-    command_codes: Sequence[str] | None,
-    include_write_restore: bool,
-    include_remote_control: bool,
-    include_maintenance: bool,
-) -> list[CompatibilityCommandSpec]:
-    enabled_risks = {COMPATIBILITY_SAFE_RISK_GROUP}
-    if include_write_restore:
-        enabled_risks.add(COMPATIBILITY_WRITE_RESTORE_RISK_GROUP)
-    if include_remote_control:
-        enabled_risks.add(COMPATIBILITY_REMOTE_RISK_GROUP)
-    if include_maintenance:
-        enabled_risks.add(COMPATIBILITY_MAINTENANCE_RISK_GROUP)
-
-    selected_codes = set(command_codes) if command_codes else None
-    specs: list[CompatibilityCommandSpec] = []
-    for spec in COMPATIBILITY_COMMAND_SPECS:
-        if spec.risk_group not in enabled_risks:
-            continue
-        if selected_codes is not None and spec.code not in selected_codes:
-            continue
-        specs.append(spec)
-    return specs
-
-
-def _compatibility_summarize_subresults(subresults: Sequence[tuple[str, str, str]]) -> str:
-    statuses = {status for _, status, _ in subresults}
-    if not statuses:
-        return "SKIP"
-    if statuses == {"SKIP"}:
-        return "SKIP"
-    if "NG" in statuses and "OK" in statuses:
-        return "PARTIAL"
-    if "NG" in statuses and "PARTIAL" in statuses:
-        return "PARTIAL"
-    if "PARTIAL" in statuses:
-        return "PARTIAL"
-    if "OK" in statuses:
-        return "OK"
-    return "NG"
-
-
-def _compatibility_format_subresults(subresults: Sequence[tuple[str, str, str]]) -> str:
-    parts: list[str] = []
-    for name, status, detail in subresults:
-        if detail:
-            parts.append(f"{name}={status} ({detail})")
-        else:
-            parts.append(f"{name}={status}")
-    return "; ".join(parts)
-
-
 def _compatibility_matrix_cell_status(results: Sequence[Mapping[str, object]]) -> str:
     executed_statuses = [str(row.get("status", "")).upper() for row in results if str(row.get("status", ""))]
     if not executed_statuses:
@@ -970,8 +913,6 @@ def _render_compatibility_matrix_markdown(
 def _default_regression_help_scripts() -> tuple[str, ...]:
     return (
         "slmp_connection_check.py",
-        "slmp_compatibility_probe.py",
-        "slmp_compatibility_matrix_render.py",
         "slmp_device_range_probe.py",
         "slmp_register_boundary_probe.py",
         "slmp_device_access_matrix_sync.py",
@@ -1815,467 +1756,6 @@ def _read_type_name_with_frame_and_series(
         return client.read_type_name()
 
 
-def _compatibility_subprobe(
-    name: str,
-    func: Callable[[], str],
-) -> tuple[str, str, str]:
-    try:
-        return (name, "OK", func())
-    except Exception as exc:  # noqa: BLE001
-        return (name, "NG", str(exc))
-
-
-def _compatibility_request_subprobe(
-    client: _StandardSlmpClient,
-    *,
-    name: str,
-    command: int | Command,
-    payload: bytes = b"",
-    subcommand: int = 0x0000,
-) -> tuple[str, str, str]:
-    try:
-        resp = client.request(command, subcommand, payload, raise_on_error=False)
-    except Exception as exc:  # noqa: BLE001
-        return (name, "NG", str(exc))
-    status = "OK" if resp.end_code == 0 else "NG"
-    return (name, status, f"end_code=0x{resp.end_code:04X}, data_len={len(resp.data)}")
-
-
-def _compatibility_probe_direct_word_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    device: str,
-    preferred_write_value: int,
-    series: PLCSeries,
-) -> str:
-    before = int(client.read_devices(device, 1, bit_unit=False, series=series)[0])
-    write_value = _choose_probe_word_value(current=before, preferred=preferred_write_value)
-    client.write_devices(device, [write_value], bit_unit=False, series=series)
-    readback = int(client.read_devices(device, 1, bit_unit=False, series=series)[0])
-    client.write_devices(device, [before], bit_unit=False, series=series)
-    restored = int(client.read_devices(device, 1, bit_unit=False, series=series)[0])
-    return (
-        f"device={device}, before=0x{before:04X}, write=0x{write_value:04X}, "
-        f"readback=0x{readback:04X}, restored=0x{restored:04X}"
-    )
-
-
-def _compatibility_probe_direct_bit_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    device: str,
-    series: PLCSeries,
-) -> str:
-    before = bool(client.read_devices(device, 1, bit_unit=True, series=series)[0])
-    write_value = not before
-    client.write_devices(device, [write_value], bit_unit=True, series=series)
-    readback = bool(client.read_devices(device, 1, bit_unit=True, series=series)[0])
-    client.write_devices(device, [before], bit_unit=True, series=series)
-    restored = bool(client.read_devices(device, 1, bit_unit=True, series=series)[0])
-    return f"device={device}, before={before}, write={write_value}, readback={readback}, restored={restored}"
-
-
-def _compatibility_probe_random_word_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    devices: Sequence[str],
-    preferred_write_value: int,
-    series: PLCSeries,
-) -> str:
-    before = client.read_random(word_devices=devices, series=series).word
-    write_pairs: list[tuple[str, int]] = []
-    for device in devices:
-        current = int(before[str(device)])
-        write_pairs.append((str(device), _choose_probe_word_value(current=current, preferred=preferred_write_value)))
-    client.write_random_words(word_values=write_pairs, series=series)
-    readback = client.read_random(word_devices=devices, series=series).word
-    restore_pairs = [(str(device), int(before[str(device)])) for device in devices]
-    client.write_random_words(word_values=restore_pairs, series=series)
-    restored = client.read_random(word_devices=devices, series=series).word
-    return (
-        f"devices={list(devices)}, before={before}, write={dict(write_pairs)}, readback={readback}, restored={restored}"
-    )
-
-
-def _compatibility_probe_random_bit_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    devices: Sequence[str],
-    series: PLCSeries,
-) -> str:
-    before = {str(device): bool(client.read_devices(device, 1, bit_unit=True, series=series)[0]) for device in devices}
-    write_pairs = [(device, not before[str(device)]) for device in devices]
-    client.write_random_bits(bit_values=write_pairs, series=series)
-    readback = {
-        str(device): bool(client.read_devices(device, 1, bit_unit=True, series=series)[0]) for device in devices
-    }
-    restore_pairs = [(device, before[str(device)]) for device in devices]
-    client.write_random_bits(bit_values=restore_pairs, series=series)
-    restored = {
-        str(device): bool(client.read_devices(device, 1, bit_unit=True, series=series)[0]) for device in devices
-    }
-    return (
-        f"devices={list(devices)}, before={before}, write={dict(write_pairs)}, readback={readback}, restored={restored}"
-    )
-
-
-def _compatibility_probe_block_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    word_device: str | None,
-    bit_device: str | None,
-    preferred_word_value: int,
-    preferred_bit_value: int,
-    series: PLCSeries,
-) -> str:
-    word_blocks = [(word_device, 1)] if word_device is not None else []
-    bit_blocks = [(bit_device, 1)] if bit_device is not None else []
-    before = client.read_block(word_blocks=word_blocks, bit_blocks=bit_blocks, series=series)
-
-    write_word_blocks: list[tuple[str, list[int]]] = []
-    write_bit_blocks: list[tuple[str, list[int]]] = []
-    if word_device is not None:
-        current = int(before.word_blocks[0].values[0])
-        write_word_blocks.append(
-            (word_device, [_choose_probe_word_value(current=current, preferred=preferred_word_value)])
-        )
-    if bit_device is not None:
-        current = int(before.bit_blocks[0].values[0])
-        write_bit_blocks.append(
-            (bit_device, [_choose_probe_word_value(current=current, preferred=preferred_bit_value)])
-        )
-
-    client.write_block(
-        word_blocks=write_word_blocks,
-        bit_blocks=write_bit_blocks,
-        series=series,
-        split_mixed_blocks=False,
-        retry_mixed_on_error=False,
-    )
-    readback = client.read_block(word_blocks=word_blocks, bit_blocks=bit_blocks, series=series)
-    restore_word_blocks = [(row.device, row.values) for row in before.word_blocks]
-    restore_bit_blocks = [(row.device, row.values) for row in before.bit_blocks]
-    client.write_block(
-        word_blocks=restore_word_blocks,
-        bit_blocks=restore_bit_blocks,
-        series=series,
-        split_mixed_blocks=False,
-        retry_mixed_on_error=False,
-    )
-    restored = client.read_block(word_blocks=word_blocks, bit_blocks=bit_blocks, series=series)
-    return (
-        f"word_device={word_device}, bit_device={bit_device}, "
-        f"before_words={before.word_blocks}, before_bits={before.bit_blocks}, "
-        f"write_words={write_word_blocks}, write_bits={write_bit_blocks}, "
-        f"readback_words={readback.word_blocks}, readback_bits={readback.bit_blocks}, "
-        f"restored_words={restored.word_blocks}, restored_bits={restored.bit_blocks}"
-    )
-
-
-def _compatibility_probe_memory_write_restore(
-    client: _StandardSlmpClient,
-    *,
-    head_address: int,
-    preferred_write_value: int,
-) -> str:
-    before = int(client.memory_read_words(head_address, 1)[0])
-    write_value = _choose_probe_word_value(current=before, preferred=preferred_write_value)
-    client.memory_write_words(head_address, [write_value])
-    readback = int(client.memory_read_words(head_address, 1)[0])
-    client.memory_write_words(head_address, [before])
-    restored = int(client.memory_read_words(head_address, 1)[0])
-    return (
-        f"head=0x{head_address:08X}, before=0x{before:04X}, write=0x{write_value:04X}, "
-        f"readback=0x{readback:04X}, restored=0x{restored:04X}"
-    )
-
-
-def _compatibility_run_command(
-    spec: CompatibilityCommandSpec,
-    client: _StandardSlmpClient,
-    *,
-    series: PLCSeries,
-    args: argparse.Namespace,
-) -> tuple[list[tuple[str, str, str]], dict[str, object]]:
-    metadata: dict[str, object] = {}
-    if spec.code == "0101":
-        try:
-            info = client.read_type_name()
-        except Exception as exc:  # noqa: BLE001
-            return ([("type_name", "NG", str(exc))], metadata)
-        model_label = _resolve_type_name_label(info)
-        model_code = _format_model_code(info.model_code)
-        inferred_series = _resolve_series_from_type_name(info)
-        metadata = {
-            "detected_model": model_label,
-            "model_code": model_code,
-            "detected_series": inferred_series.value if inferred_series is not None else None,
-        }
-        return ([("type_name", "OK", f"model={model_label}, model_code={model_code}")], metadata)
-    if spec.code == "0401":
-        return (
-            [
-                _compatibility_subprobe(
-                    "word_read",
-                    lambda: (
-                        f"device={args.word_device}, values={client.read_devices(args.word_device, 1, series=series)}"
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "bit_read",
-                    lambda: (
-                        f"device={args.bit_device}, "
-                        f"values={client.read_devices(args.bit_device, 1, bit_unit=True, series=series)}"
-                    ),
-                ),
-            ],
-            metadata,
-        )
-    if spec.code == "1401":
-        return (
-            [
-                _compatibility_subprobe(
-                    "word_write_restore",
-                    lambda: _compatibility_probe_direct_word_write_restore(
-                        client,
-                        device=args.word_device,
-                        preferred_write_value=args.word_write_value,
-                        series=series,
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "bit_write_restore",
-                    lambda: _compatibility_probe_direct_bit_write_restore(
-                        client,
-                        device=args.bit_device,
-                        series=series,
-                    ),
-                ),
-            ],
-            metadata,
-        )
-    if spec.code == "0403":
-        return (
-            [
-                _compatibility_subprobe(
-                    "random_read",
-                    lambda: (
-                        f"devices={args.random_read_word_device}, "
-                        f"values={client.read_random(word_devices=args.random_read_word_device, series=series).word}"
-                    ),
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "1402":
-        return (
-            [
-                _compatibility_subprobe(
-                    "random_word_write_restore",
-                    lambda: _compatibility_probe_random_word_write_restore(
-                        client,
-                        devices=args.random_write_word_device,
-                        preferred_write_value=args.random_write_word_value,
-                        series=series,
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "random_bit_write_restore",
-                    lambda: _compatibility_probe_random_bit_write_restore(
-                        client,
-                        devices=args.random_write_bit_device,
-                        series=series,
-                    ),
-                ),
-            ],
-            metadata,
-        )
-    if spec.code == "0801":
-
-        def _monitor_entry_detail() -> str:
-            client.register_monitor_devices(word_devices=[args.monitor_word_device], series=series)
-            return f"word_device={args.monitor_word_device}"
-
-        return (
-            [
-                _compatibility_subprobe(
-                    "monitor_entry",
-                    _monitor_entry_detail,
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "0802":
-
-        def _monitor_execute_detail() -> str:
-            client.register_monitor_devices(word_devices=[args.monitor_word_device], series=series)
-            result = client.run_monitor_cycle(word_points=1, dword_points=0)
-            return f"word_device={args.monitor_word_device}, values={result.word}"
-
-        return ([_compatibility_subprobe("monitor_execute", _monitor_execute_detail)], metadata)
-    if spec.code == "0406":
-
-        def _block_read_mixed_detail() -> str:
-            result = client.read_block(
-                word_blocks=[(args.block_word_device, 1)],
-                bit_blocks=[(args.block_bit_device, 1)],
-                series=series,
-            )
-            return f"word_device={args.block_word_device}, bit_device={args.block_bit_device}, result={result}"
-
-        return (
-            [
-                _compatibility_subprobe(
-                    "block_read_word_only",
-                    lambda: (
-                        f"device={args.block_word_device}, "
-                        "result="
-                        f"{client.read_block(word_blocks=[(args.block_word_device, 1)], series=series).word_blocks}"
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "block_read_bit_only",
-                    lambda: (
-                        f"device={args.block_bit_device}, "
-                        f"result={client.read_block(bit_blocks=[(args.block_bit_device, 1)], series=series).bit_blocks}"
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "block_read_mixed",
-                    _block_read_mixed_detail,
-                ),
-            ],
-            metadata,
-        )
-    if spec.code == "1406":
-        return (
-            [
-                _compatibility_subprobe(
-                    "block_write_word_only",
-                    lambda: _compatibility_probe_block_write_restore(
-                        client,
-                        word_device=args.block_word_device,
-                        bit_device=None,
-                        preferred_word_value=args.block_word_write_value,
-                        preferred_bit_value=args.block_bit_write_value,
-                        series=series,
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "block_write_bit_only",
-                    lambda: _compatibility_probe_block_write_restore(
-                        client,
-                        word_device=None,
-                        bit_device=args.block_bit_device,
-                        preferred_word_value=args.block_word_write_value,
-                        preferred_bit_value=args.block_bit_write_value,
-                        series=series,
-                    ),
-                ),
-                _compatibility_subprobe(
-                    "block_write_mixed",
-                    lambda: _compatibility_probe_block_write_restore(
-                        client,
-                        word_device=args.block_word_device,
-                        bit_device=args.block_bit_device,
-                        preferred_word_value=args.block_word_write_value,
-                        preferred_bit_value=args.block_bit_write_value,
-                        series=series,
-                    ),
-                ),
-            ],
-            metadata,
-        )
-    if spec.code == "1001":
-        return (
-            [
-                _compatibility_request_subprobe(
-                    client,
-                    name="remote_run",
-                    command=Command.REMOTE_RUN,
-                    payload=b"\x01\x00\x00\x00",
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "1002":
-        return (
-            [
-                _compatibility_request_subprobe(
-                    client,
-                    name="remote_stop",
-                    command=Command.REMOTE_STOP,
-                    payload=b"\x01\x00",
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "1005":
-        return (
-            [
-                _compatibility_request_subprobe(
-                    client,
-                    name="remote_latch_clear",
-                    command=Command.REMOTE_LATCH_CLEAR,
-                    payload=b"\x01\x00",
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "0619":
-        return (
-            [
-                _compatibility_request_subprobe(
-                    client,
-                    name="self_test",
-                    command=Command.SELF_TEST,
-                    payload=b"\x04\x00\x11\x22\x33\x44",
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "0613":
-        return (
-            [
-                _compatibility_subprobe(
-                    "memory_read",
-                    lambda: (
-                        f"head=0x{args.memory_head:08X}, "
-                        f"values={client.memory_read_words(args.memory_head, args.memory_length)}"
-                    ),
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "1613":
-        return (
-            [
-                _compatibility_subprobe(
-                    "memory_write_restore",
-                    lambda: _compatibility_probe_memory_write_restore(
-                        client,
-                        head_address=args.memory_head,
-                        preferred_write_value=args.memory_write_value,
-                    ),
-                )
-            ],
-            metadata,
-        )
-    if spec.code == "1617":
-        return (
-            [
-                _compatibility_request_subprobe(
-                    client,
-                    name="clear_error",
-                    command=Command.CLEAR_ERROR,
-                    payload=b"",
-                )
-            ],
-            metadata,
-        )
-    raise ValueError(f"unsupported compatibility command code: {spec.code}")
-
-
 def _probe_sm400_series(client: _StandardSlmpClient) -> tuple[PLCSeries, list[bool]]:
     series, values = _probe_device_read_with_series(
         client,
@@ -4984,258 +4464,6 @@ def pending_live_verification_main(argv: Sequence[str] | None = None) -> int:
     return 0
 
 
-def compatibility_probe_main(argv: Sequence[str] | None = None) -> int:
-    """Probe SLMP compatibility across frame/profile combinations."""
-    parser = argparse.ArgumentParser(description="Probe SLMP compatibility across frame/profile combinations")
-    parser.add_argument("--host", required=True)
-    parser.add_argument("--port", type=int, default=1025)
-    parser.add_argument("--transport", choices=("tcp", "udp"), default="tcp")
-    parser.add_argument("--timeout", type=float, default=3.0)
-    parser.add_argument("--series", choices=("ql", "iqr"), default="ql")
-    parser.add_argument("--frame-type", choices=("3e", "4e"), default="3e")
-    parser.add_argument("--monitoring-timer", type=_int_auto, default=0x0010, help="e.g. 0x0010")
-    parser.add_argument("--network", type=_int_auto, default=0x00)
-    parser.add_argument("--station", type=_int_auto, default=0xFF)
-    parser.add_argument("--module-io", type=_int_auto, default=0x03FF)
-    parser.add_argument("--multidrop", type=_int_auto, default=0x00)
-    parser.add_argument(
-        "--target",
-        help="optional SELF, SELF-CPU1..4, NWx-STy, or NAME,NETWORK,STATION,MODULE_IO,MULTIDROP",
-    )
-    parser.add_argument("--plc-label", help="stable label used for JSON/matrix output")
-    parser.add_argument("--command", action="append", choices=COMPATIBILITY_COMMAND_CODES)
-    parser.add_argument("--include-write-restore", action="store_true", help="include write/readback/restore probes")
-    parser.add_argument("--include-remote-control", action="store_true", help="include remote RUN/STOP/Latch Clear")
-    parser.add_argument("--include-maintenance", action="store_true", help="include Clear Error")
-    parser.add_argument("--word-device", default="D130")
-    parser.add_argument("--bit-device", default="M120")
-    parser.add_argument("--random-read-word-device", action="append")
-    parser.add_argument("--random-write-word-device", action="append")
-    parser.add_argument("--random-write-bit-device", action="append")
-    parser.add_argument("--monitor-word-device", default="D130")
-    parser.add_argument("--block-word-device", default="D140")
-    parser.add_argument("--block-bit-device", default="M140")
-    parser.add_argument("--memory-head", type=_int_auto, default=0x0000)
-    parser.add_argument("--memory-length", type=int, default=1)
-    parser.add_argument("--word-write-value", type=_int_auto, default=0x0000)
-    parser.add_argument("--random-write-word-value", type=_int_auto, default=0x0000)
-    parser.add_argument("--block-word-write-value", type=_int_auto, default=0x0000)
-    parser.add_argument("--block-bit-write-value", type=_int_auto, default=0x0000)
-    parser.add_argument("--memory-write-value", type=_int_auto, default=0x0000)
-    parser.add_argument("--output-markdown")
-    parser.add_argument("--output-json")
-    args = parser.parse_args(list(argv) if argv is not None else None)
-
-    selected_specs = _compatibility_selected_specs(
-        command_codes=args.command,
-        include_write_restore=args.include_write_restore,
-        include_remote_control=args.include_remote_control,
-        include_maintenance=args.include_maintenance,
-    )
-    if not selected_specs:
-        parser.error("no commands selected; enable at least one probe group or command")
-    if args.command:
-        selected_codes = {spec.code for spec in selected_specs}
-        missing = [code for code in args.command if code not in selected_codes]
-        if missing:
-            parser.error(
-                "requested commands are not enabled by the selected risk flags: " + ", ".join(sorted(set(missing)))
-            )
-
-    if args.target:
-        try:
-            target = _parse_named_target(args.target).target
-        except ValueError as exc:
-            parser.error(str(exc))
-    else:
-        target = SlmpTarget(
-            network=args.network,
-            station=args.station,
-            module_io=args.module_io,
-            multidrop=args.multidrop,
-        )
-
-    args.random_read_word_device = args.random_read_word_device or [args.word_device, "D131"]
-    args.random_write_word_device = args.random_write_word_device or ["D135"]
-    args.random_write_bit_device = args.random_write_bit_device or ["M125"]
-    plc_label = args.plc_label or f"{args.host}_n{target.network:02X}_s{target.station:02X}"
-    markdown_output = args.output_markdown or _compatibility_default_output(
-        plc_label=plc_label,
-        filename="compatibility_probe_latest.md",
-    )
-    json_output = args.output_json or _compatibility_default_output(
-        plc_label=plc_label,
-        filename="compatibility_probe_latest.json",
-    )
-
-    frame_candidates = [FrameType(args.frame_type)]
-    series_candidates = [PLCSeries(args.series)]
-
-    rows: list[tuple[str, str, str]] = []
-    result_rows: list[dict[str, object]] = []
-    selected_command_codes = [spec.code for spec in selected_specs]
-    risk_groups = sorted({spec.risk_group for spec in selected_specs})
-
-    print("=== Compatibility Probe ===")
-    print(f"PLC Label={plc_label}")
-    print(f"Host={args.host}, Port={args.port}, Transport={args.transport}")
-    print(
-        "Target="
-        f"network=0x{target.network:02X}, station=0x{target.station:02X}, "
-        f"module_io=0x{target.module_io:04X}, multidrop=0x{target.multidrop:02X}"
-    )
-    print(
-        "Combinations="
-        + ",".join(f"{frame.value}/{series.value}" for frame in frame_candidates for series in series_candidates)
-    )
-    print(f"Commands={','.join(selected_command_codes)}")
-
-    for frame_type in frame_candidates:
-        for series in series_candidates:
-            combo_label = f"{frame_type.value}/{series.value}"
-            command_rows: list[dict[str, object]] = []
-            combo_result: dict[str, object] = {
-                "frame_type": frame_type.value,
-                "access_profile": series.value,
-                "commands": command_rows,
-            }
-            try:
-                with SlmpClient(
-                    args.host,
-                    port=args.port,
-                    transport=args.transport,
-                    timeout=args.timeout,
-                    plc_series=series,
-                    frame_type=frame_type,
-                    default_target=target,
-                    monitoring_timer=args.monitoring_timer,
-                ) as client:
-                    for spec in selected_specs:
-                        subresults, metadata = _compatibility_run_command(spec, client, series=series, args=args)
-                        status = _compatibility_summarize_subresults(subresults)
-                        detail = _compatibility_format_subresults(subresults)
-                        item = f"{combo_label} {spec.code} {spec.name}"
-                        rows.append((item, status, detail))
-                        print(f"[{status}] {item}: {detail}")
-                        command_row: dict[str, object] = {
-                            "code": spec.code,
-                            "category": spec.category,
-                            "name": spec.name,
-                            "risk_group": spec.risk_group,
-                            "status": status,
-                            "detail": detail,
-                            "subresults": [
-                                {"name": name, "status": sub_status, "detail": sub_detail}
-                                for name, sub_status, sub_detail in subresults
-                            ],
-                        }
-                        command_rows.append(command_row)
-                        for key, value in metadata.items():
-                            if value is not None and key not in combo_result:
-                                combo_result[key] = value
-            except Exception as exc:  # noqa: BLE001
-                detail = str(exc)
-                print(f"[NG] {combo_label} connection: {detail}")
-                combo_result["connection_error"] = detail
-                for spec in selected_specs:
-                    item = f"{combo_label} {spec.code} {spec.name}"
-                    rows.append((item, "NG", detail))
-                    command_rows.append(
-                        {
-                            "code": spec.code,
-                            "category": spec.category,
-                            "name": spec.name,
-                            "risk_group": spec.risk_group,
-                            "status": "NG",
-                            "detail": detail,
-                            "subresults": [{"name": "connection", "status": "NG", "detail": detail}],
-                        }
-                    )
-            result_rows.append(combo_result)
-
-    json_payload: dict[str, object] = {
-        "schema_version": 1,
-        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "plc_label": plc_label,
-        "host": args.host,
-        "port": args.port,
-        "transport": args.transport,
-        "requested_series": args.series,
-        "requested_frame_type": args.frame_type,
-        "risk_groups": risk_groups,
-        "selected_commands": selected_command_codes,
-        "target": {
-            "network": target.network,
-            "station": target.station,
-            "module_io": int(target.module_io),
-            "multidrop": target.multidrop,
-        },
-        "results": result_rows,
-    }
-    _write_json_report(json_output, json_payload)
-
-    summary = Counter(status for _, status, _ in rows)
-    _write_markdown_report(
-        markdown_output,
-        title="# Compatibility Probe Report",
-        header_lines=[
-            f"- Date: {json_payload['generated_at']}",
-            f"- PLC Label: {plc_label}",
-            f"- Host: {args.host}",
-            f"- Port: {args.port}",
-            f"- Transport: {args.transport}",
-            f"- Requested series: {args.series}",
-            f"- Requested frame: {args.frame_type}",
-            (
-                f"- Target: network=0x{target.network:02X}, station=0x{target.station:02X}, "
-                f"module_io=0x{int(target.module_io):04X}, multidrop=0x{target.multidrop:02X}"
-            ),
-            f"- Risk groups: {', '.join(risk_groups)}",
-            f"- Commands: {', '.join(selected_command_codes)}",
-            f"- Summary: OK={summary['OK']}, PARTIAL={summary['PARTIAL']}, NG={summary['NG']}, SKIP={summary['SKIP']}",
-            f"- JSON: {json_output}",
-        ],
-        rows=rows,
-    )
-    print(f"[DONE] markdown={markdown_output}")
-    print(f"[DONE] json={json_output}")
-    return 0
-
-
-def compatibility_matrix_render_main(argv: Sequence[str] | None = None) -> int:
-    """Render PLC_COMPATIBILITY.md from compatibility probe JSON files."""
-    parser = argparse.ArgumentParser(description="Render PLC_COMPATIBILITY.md from compatibility probe JSON files")
-    parser.add_argument("--input", action="append", required=True, help="compatibility_probe_latest.json; repeatable")
-    parser.add_argument("--output", default="internal_docs/validation/reports/PLC_COMPATIBILITY.md")
-    parser.add_argument(
-        "--policy-output",
-        default=_compatibility_default_policy_output(),
-        help="structured policy JSON generated from the same probe inputs",
-    )
-    parser.add_argument(
-        "--omit-pending-columns",
-        action="store_true",
-        help="hide command columns that are PENDING for every PLC row",
-    )
-    args = parser.parse_args(list(argv) if argv is not None else None)
-
-    source_paths = [Path(path) for path in args.input]
-    loaded: list[Mapping[str, object]] = []
-    for path in source_paths:
-        loaded.append(json.loads(path.read_text(encoding="utf-8")))
-
-    content = _render_compatibility_matrix_markdown(
-        loaded,
-        source_paths=source_paths,
-        omit_pending_columns=args.omit_pending_columns,
-    )
-    _write_text_report(args.output, content)
-    _write_json_report(args.policy_output, _build_compatibility_policy(loaded))
-    print(f"[DONE] output={args.output}")
-    print(f"[DONE] policy={args.policy_output}")
-    return 0
-
-
 def device_access_matrix_sync_main(argv: Sequence[str] | None = None) -> int:
     """Render device_access_matrix.md from device_access_matrix.csv."""
     parser = argparse.ArgumentParser(description="Render device_access_matrix.md from device_access_matrix.csv")

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/slmp/core.py

@@ -1271,7 +1271,7 @@ _RANDOM_DWORD_ONLY_DIRECT_CODES = frozenset({"LCN", "LZ"})
 _G_HG_CODES = frozenset({"G", "HG"})
 _TEMPORARILY_UNSUPPORTED_TYPED_CODES = frozenset({"G", "HG"})
 _BOUNDARY_START_ACCEPTANCE_CODES = frozenset({"R", "ZR"})
-_MIXED_BLOCK_RETRY_END_CODES = frozenset({0xC056, 0xC05B, 0xC061})
+_MIXED_BLOCK_RETRY_END_CODES = frozenset({0xC056, 0xC061})
 
 
 def _encode_label_name(label: str) -> bytes:

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15/slmp_connect_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slmp-connect-python
-Version: 0.1.14
+Version: 0.1.15
 Summary: SLMP Connect Python: client library for Mitsubishi SLMP binary communication
 Author: fa-yoshinobu
 License-Expression: MIT
@@ -43,6 +43,13 @@ Dynamic: license-file
 
 ![Illustration](https://raw.githubusercontent.com/fa-yoshinobu/plc-comm-slmp-python/main/docsrc/assets/melsec.png)
 
+[![Automated Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/automated-release.yml)
+[![Release](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml/badge.svg)](https://github.com/fa-yoshinobu/plc-comm-slmp-python/actions/workflows/release.yml)
+
+[![Python](https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white)](https://www.python.org/)
+[![MkDocs](https://img.shields.io/badge/MkDocs-526CFE?logo=materialformkdocs&logoColor=white)](https://www.mkdocs.org/)
+[![GitHub Pages](https://img.shields.io/badge/GitHub%20Pages-222222?logo=githubpages&logoColor=white)](https://pages.github.com/)
+
 High-level SLMP helpers for Mitsubishi PLC communication over Binary 3E and 4E frames.
 
 This repository treats the high-level helper layer as the recommended user surface:

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/slmp_connect_python.egg-info/entry_points.txt

@@ -1,6 +1,4 @@
 [console_scripts]
-slmp-compatibility-matrix-render = slmp.cli:compatibility_matrix_render_main
-slmp-compatibility-probe = slmp.cli:compatibility_probe_main
 slmp-connection-check = slmp.cli:connection_check_main
 slmp-device-access-matrix-sync = slmp.cli:device_access_matrix_sync_main
 slmp-device-range-probe = slmp.cli:device_range_probe_main

{slmp_connect_python-0.1.14 → slmp_connect_python-0.1.15}/tests/test_slmp.py

@@ -1221,169 +1221,6 @@ class TestCli(unittest.TestCase):
         self.assertEqual(PolicyOtherStationClient.type_name_calls, [("4e", "ql")])
         self.assertIn("Resolved frame: 4e", report)
 
-    def test_compatibility_probe_main_writes_json_and_markdown(self) -> None:
-        """Test test_compatibility_probe_main_writes_json_and_markdown."""
-
-        class CompatibilityProbeClient(SlmpClient):
-            def __init__(
-                self,
-                host: str,
-                port: int = 5000,
-                *,
-                transport: str = "tcp",
-                timeout: float = 3.0,
-                plc_series: PLCSeries | str = PLCSeries.QL,
-                frame_type: cli.FrameType | str = cli.FrameType.FRAME_4E,
-                default_target: SlmpTarget | None = None,
-                monitoring_timer: int = 0x0010,
-                raise_on_error: bool = True,
-                trace_hook=None,
-            ) -> None:
-                super().__init__(
-                    host,
-                    port,
-                    transport=transport,
-                    timeout=timeout,
-                    plc_series=plc_series,
-                    frame_type=frame_type,
-                    default_target=default_target,
-                    monitoring_timer=monitoring_timer,
-                    raise_on_error=raise_on_error,
-                    trace_hook=trace_hook,
-                )
-
-            def connect(self) -> None:
-                return None
-
-            def close(self) -> None:
-                return None
-
-            def read_type_name(self) -> TypeNameInfo:
-                return TypeNameInfo(raw=b"\x00" * 18, model="Q26UDEHCPU", model_code=0x026C)
-
-            def read_devices(self, device, points, *, bit_unit=False, series=None):  # type: ignore[override]
-                if bit_unit:
-                    return [True]
-                return [0]
-
-            def read_block(self, *, word_blocks=(), bit_blocks=(), series=None, split_mixed_blocks=False):  # type: ignore[override]
-                return BlockReadResult(word_blocks=[], bit_blocks=[])
-
-        with TemporaryDirectory() as tmp:
-            output_md = Path(tmp) / "compatibility_probe_latest.md"
-            output_json = Path(tmp) / "compatibility_probe_latest.json"
-            with patch.object(cli, "SlmpClient", CompatibilityProbeClient):
-                rc = cli.compatibility_probe_main(
-                    [
-                        "--host",
-                        "192.168.250.100",
-                        "--plc-label",
-                        "Q26UDEHCPU_BuiltIn",
-                        "--series",
-                        "ql",
-                        "--frame-type",
-                        "3e",
-                        "--command",
-                        "0101",
-                        "--command",
-                        "0401",
-                        "--command",
-                        "0406",
-                        "--output-markdown",
-                        str(output_md),
-                        "--output-json",
-                        str(output_json),
-                    ]
-                )
-            report = output_md.read_text(encoding="utf-8")
-            payload = json.loads(output_json.read_text(encoding="utf-8"))
-
-        self.assertEqual(rc, 0)
-        self.assertEqual(payload["plc_label"], "Q26UDEHCPU_BuiltIn")
-        self.assertEqual(payload["selected_commands"], ["0101", "0401", "0406"])
-        self.assertEqual(payload["results"][0]["frame_type"], "3e")
-        self.assertEqual(payload["results"][0]["access_profile"], "ql")
-        self.assertEqual(payload["results"][0]["detected_model"], "Q26UDHCPU, Q26UDEHCPU")
-        self.assertIn("3e/ql 0101 Read Type Name", report)
-        self.assertIn("3e/ql 0406 Block Read", report)
-
-    def test_compatibility_probe_main_rejects_auto_series_and_frame(self) -> None:
-        """Test test_compatibility_probe_main_rejects_auto_series_and_frame."""
-
-        with self.assertRaises(SystemExit) as cm:
-            cli.compatibility_probe_main(
-                [
-                    "--host",
-                    "192.168.250.100",
-                    "--series",
-                    "auto",
-                    "--frame-type",
-                    "auto",
-                ]
-            )
-
-        self.assertEqual(cm.exception.code, 2)
-
-    def test_compatibility_matrix_render_main_renders_output(self) -> None:
-        """Test test_compatibility_matrix_render_main_renders_output."""
-        with TemporaryDirectory() as tmp:
-            input_a = Path(tmp) / "probe_a.json"
-            input_b = Path(tmp) / "probe_b.json"
-            output = Path(tmp) / "PLC_COMPATIBILITY.md"
-            policy_output = Path(tmp) / "compatibility_policy.json"
-            input_a.write_text(
-                json.dumps(
-                    {
-                        "plc_label": "PLC-A",
-                        "results": [
-                            {
-                                "frame_type": "3e",
-                                "access_profile": "ql",
-                                "commands": [{"code": "0101", "status": "OK"}],
-                            }
-                        ],
-                    }
-                ),
-                encoding="utf-8",
-            )
-            input_b.write_text(
-                json.dumps(
-                    {
-                        "plc_label": "PLC-B",
-                        "results": [
-                            {
-                                "frame_type": "4e",
-                                "access_profile": "iqr",
-                                "commands": [{"code": "0101", "status": "NG"}],
-                            }
-                        ],
-                    }
-                ),
-                encoding="utf-8",
-            )
-            rc = cli.compatibility_matrix_render_main(
-                [
-                    "--input",
-                    str(input_a),
-                    "--input",
-                    str(input_b),
-                    "--omit-pending-columns",
-                    "--policy-output",
-                    str(policy_output),
-                    "--output",
-                    str(output),
-                ]
-            )
-            content = output.read_text(encoding="utf-8")
-            policy = json.loads(policy_output.read_text(encoding="utf-8"))
-
-        self.assertEqual(rc, 0)
-        self.assertIn("| PLC-A | unknown_target | YES |", content)
-        self.assertIn("| PLC-B | unknown_target | NO |", content)
-        self.assertNotIn("**1401**", content)
-        self.assertIn("global", policy)
-        self.assertIn("preferred_profiles", policy["global"])
-
     def test_manual_label_verification_main_requires_label_args(self) -> None:
         """Test test_manual_label_verification_main_requires_label_args."""
         with self.assertRaises(SystemExit) as ctx:
@@ -2288,25 +2125,19 @@ class TestDeviceApi(unittest.TestCase):
         self.assertEqual(len(client.requests), 1)
         self.assertEqual(client.requests[0][0], Command.DEVICE_WRITE_BLOCK)
 
-    def test_write_block_retry_mixed_on_c05b_splits_after_failed_combined_request(self) -> None:
-        """Test test_write_block_retry_mixed_on_c05b_splits_after_failed_combined_request."""
-        client = FakeClient()
-        client.response_queue = [(0xC05B, b""), (0x0000, b""), (0x0000, b"")]
-        with warnings.catch_warnings(record=True) as caught:
-            warnings.simplefilter("always")
-            client.write_block(
-                word_blocks=[("D100", [0x1111])],
-                bit_blocks=[("M200", [0x0001])],
-                series=PLCSeries.IQR,
-                retry_mixed_on_error=True,
-            )
-        self.assertEqual(len(client.requests), 3)
-        self.assertEqual([request[0] for request in client.requests], [Command.DEVICE_WRITE_BLOCK] * 3)
-        self.assertEqual([request[2][:2] for request in client.requests], [b"\x01\x01", b"\x01\x00", b"\x00\x01"])
-        self.assertTrue(all(request[3]["raise_on_error"] is False for request in client.requests))
-        self.assertTrue(
-            any(isinstance(item.message, SlmpPracticalPathWarning) and "0xC05B" in str(item.message) for item in caught)
-        )
+    def test_write_block_retry_mixed_on_c05b_does_not_split(self) -> None:
+        """Test test_write_block_retry_mixed_on_c05b_does_not_split."""
+        client = FakeClient()
+        client.response_queue = [(0xC05B, b"")]
+        with self.assertRaises(SlmpError) as ctx:
+            client.write_block(
+                word_blocks=[("D100", [0x1111])],
+                bit_blocks=[("M200", [0x0001])],
+                series=PLCSeries.IQR,
+                retry_mixed_on_error=True,
+            )
+        self.assertEqual(ctx.exception.end_code, 0xC05B)
+        self.assertEqual(len(client.requests), 1)
 
     def test_write_block_retry_mixed_on_c056_splits_after_failed_combined_request(self) -> None:
         """Test test_write_block_retry_mixed_on_c056_splits_after_failed_combined_request."""