slmp-connect-python 1.0.0__tar.gz → 1.0.1__tar.gz

{slmp_connect_python-1.0.0/slmp_connect_python.egg-info → slmp_connect_python-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slmp-connect-python
-Version: 1.0.0
+Version: 1.0.1
 Summary: SLMP Connect Python: client library for MELSEC SLMP binary communication
 Author: fa-yoshinobu
 License-Expression: MIT

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slmp-connect-python"
-version = "1.0.0"
+version = "1.0.1"
 description = "SLMP Connect Python: client library for MELSEC SLMP binary communication"
 readme = "README.md"
 requires-python = ">=3.10"

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/slmp/__init__.py

@@ -10,7 +10,7 @@ The primary user-facing entry points are:
 - ``poll``
 """
 
-__version__ = "0.8.0"
+__version__ = "1.0.1"
 
 from .async_client import AsyncSlmpClient
 from .client import SlmpClient

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/slmp/_operations.py

@@ -85,7 +85,7 @@ def _effective_series(series: PLCSeries | str | None, default_series: PLCSeries)
     return PLCSeries(series) if series is not None else default_series
 
 
-def _parse_device_for_family(device: str | DeviceRef, address_profile: object | None) -> DeviceRef:
+def _parse_device_for_address_profile(device: str | DeviceRef, address_profile: object | None) -> DeviceRef:
     ref = parse_device(device, plc_profile=address_profile)
     return _require_explicit_plc_profile_for_xy(device, address_profile, ref)
 
@@ -110,7 +110,7 @@ def build_read_devices_request(
 ) -> OperationRequest:
     _check_direct_device_points(points, bit_unit=bit_unit, name="read_devices")
     effective_series = _effective_series(series, default_series)
-    ref = _parse_device_for_family(device, address_profile)
+    ref = _parse_device_for_address_profile(device, address_profile)
     _validate_direct_read_device(ref, points=points, bit_unit=bit_unit)
     _check_temporarily_unsupported_device(ref)
     _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
@@ -154,7 +154,7 @@ def build_write_devices_request(
         raise ValueError("values must not be empty")
     _check_direct_device_points(len(values), bit_unit=bit_unit, name="write_devices")
     effective_series = _effective_series(series, default_series)
-    ref = _parse_device_for_family(device, address_profile)
+    ref = _parse_device_for_address_profile(device, address_profile)
     _validate_direct_write_device(ref, bit_unit=bit_unit)
     _check_temporarily_unsupported_device(ref)
     _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
@@ -188,7 +188,7 @@ def build_read_dwords_request(
 ) -> OperationRequest:
     if count < 1:
         raise ValueError("count must be >= 1")
-    ref = _parse_device_for_family(device, address_profile)
+    ref = _parse_device_for_address_profile(device, address_profile)
     _validate_direct_dword_read_device(ref)
     return build_read_devices_request(
         ref,
@@ -342,12 +342,12 @@ def build_register_monitor_devices_request(
     word_refs: list[DeviceRef] = []
     dword_refs: list[DeviceRef] = []
     for dev in word_devices:
-        ref = _parse_device_for_family(dev, address_profile)
+        ref = _parse_device_for_address_profile(dev, address_profile)
         _check_temporarily_unsupported_device(ref)
         payload += encode_device_spec(ref, series=effective_series)
         word_refs.append(ref)
     for dev in dword_devices:
-        ref = _parse_device_for_family(dev, address_profile)
+        ref = _parse_device_for_address_profile(dev, address_profile)
         _check_temporarily_unsupported_device(ref)
         payload += encode_device_spec(ref, series=effective_series)
         dword_refs.append(ref)
@@ -499,8 +499,8 @@ def build_read_random_request(
     )
     subcommand = resolve_device_subcommand(bit_unit=False, series=effective_series, extension=False)
 
-    words = [_parse_device_for_family(device, address_profile) for device in word_devices]
-    dwords = [_parse_device_for_family(device, address_profile) for device in dword_devices]
+    words = [_parse_device_for_address_profile(device, address_profile) for device in word_devices]
+    dwords = [_parse_device_for_address_profile(device, address_profile) for device in dword_devices]
     _validate_random_read_devices(words, dwords)
     _check_temporarily_unsupported_devices(words)
     _check_temporarily_unsupported_devices(dwords)
@@ -718,7 +718,7 @@ def build_read_block_request(
     normalized_bit: list[tuple[DeviceRef, int]] = []
     for device, points in word_blocks:
         _check_points_u16(points, "word_block points")
-        ref = _parse_device_for_family(device, address_profile)
+        ref = _parse_device_for_address_profile(device, address_profile)
         _check_temporarily_unsupported_device(ref)
         _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
         normalized_word.append((ref, points))
@@ -726,7 +726,7 @@ def build_read_block_request(
         payload += points.to_bytes(2, "little")
     for device, points in bit_blocks:
         _check_points_u16(points, "bit_block points")
-        ref = _parse_device_for_family(device, address_profile)
+        ref = _parse_device_for_address_profile(device, address_profile)
         _check_temporarily_unsupported_device(ref)
         _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
         normalized_bit.append((ref, points))
@@ -784,13 +784,13 @@ def build_write_block_request(
     word_refs: list[DeviceRef] = []
     bit_refs: list[DeviceRef] = []
     for device, values in word_blocks:
-        ref = _parse_device_for_family(device, address_profile)
+        ref = _parse_device_for_address_profile(device, address_profile)
         _check_temporarily_unsupported_device(ref)
         _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
         _check_points_u16(len(values), "word block size")
         word_refs.append(ref)
     for device, values in bit_blocks:
-        ref = _parse_device_for_family(device, address_profile)
+        ref = _parse_device_for_address_profile(device, address_profile)
         _check_temporarily_unsupported_device(ref)
         _warn_practical_device_path(ref, series=effective_series, access_kind="direct")
         _check_points_u16(len(values), "bit block size")

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/slmp/async_client.py

@@ -91,7 +91,7 @@ class AsyncSlmpClient:
 
         The standard async client route requires ``plc_profile`` and fixes the
         frame type, access profile, and address/range handling from that one
-        explicit family.
+        explicit PLC profile.
         """
         self.host = host
         self.transport_type = transport.lower()

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/slmp/device_ranges.py

@@ -518,7 +518,7 @@ def normalize_plc_profile(value: SlmpPlcProfile | str) -> SlmpPlcProfile:
 
     if isinstance(value, SlmpPlcProfile):
         return value
-    normalized = str(value).strip().lower()
+    normalized = str(value).strip()
     if normalized in _CANONICAL_FAMILIES:
         return _CANONICAL_FAMILIES[normalized]
     supported = ", ".join(sorted(_CANONICAL_FAMILIES))

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1}/slmp/utils.py

@@ -13,7 +13,6 @@ from .constants import DEVICE_CODES, DeviceUnit, FrameType, PLCSeries
 from .core import (
     DeviceRef,
     SlmpTarget,
-    _normalize_plc_profile_hint,
     _require_explicit_plc_profile_for_xy,
     _resolve_connection_profile,
     _resolve_plc_profile_defaults,
@@ -142,30 +141,30 @@ class SlmpAddress:
 
 
 def _client_address_profile(client: object) -> str | None:
-    family = getattr(client, "address_profile", None)
-    if family is None:
+    address_profile = getattr(client, "address_profile", None)
+    if address_profile is None:
         return None
-    if isinstance(family, str):
-        return family
-    value = getattr(family, "value", None)
+    if isinstance(address_profile, str):
+        return address_profile
+    value = getattr(address_profile, "value", None)
     if isinstance(value, str):
         return value
     return None
 
 
-def _parse_device_for_family(
+def _parse_device_for_address_profile(
     device: str | DeviceRef,
-    family: object | None = None,
+    address_profile: object | None = None,
 ) -> DeviceRef:
-    ref = parse_device(device, plc_profile=family)
-    return _require_explicit_plc_profile_for_xy(device, family, ref)
+    ref = parse_device(device, plc_profile=address_profile)
+    return _require_explicit_plc_profile_for_xy(device, address_profile, ref)
 
 
 def _parse_device_for_client(
     client: object,
     device: str | DeviceRef,
 ) -> DeviceRef:
-    return _parse_device_for_family(device, _client_address_profile(client))
+    return _parse_device_for_address_profile(device, _client_address_profile(client))
 
 
 def _validate_dword_read_target(client: object, device: str | DeviceRef) -> DeviceRef:
@@ -183,7 +182,7 @@ async def read_typed(
     client: AsyncSlmpClient,
     device: str | DeviceRef,
     dtype: str,
-) -> int | float:
+) -> int | float | bool:
     """Read one logical value and convert it to a Python scalar.
 
     Args:
@@ -225,7 +224,7 @@ async def write_typed(
     client: AsyncSlmpClient,
     device: str | DeviceRef,
     dtype: str,
-    value: int | float,
+    value: int | float | bool,
 ) -> None:
     """Write one logical value using the requested application type.
 
@@ -266,7 +265,7 @@ def read_typed_sync(
     client: SlmpClient,
     device: str | DeviceRef,
     dtype: str,
-) -> int | float:
+) -> int | float | bool:
     """Synchronously read one logical value as a Python scalar."""
     ref = _parse_device_for_client(client, device)
     key = dtype.upper()
@@ -297,7 +296,7 @@ def write_typed_sync(
     client: SlmpClient,
     device: str | DeviceRef,
     dtype: str,
-    value: int | float,
+    value: int | float | bool,
 ) -> None:
     """Synchronously write one logical value using the requested type."""
     ref = _parse_device_for_client(client, device)
@@ -413,7 +412,7 @@ async def read_named(
         The address list is compiled once, then grouped into random reads where
         possible. Use ``.bit`` notation only with word devices.
     """
-    plan = _compile_read_plan(addresses, family=_client_address_profile(client))
+    plan = _compile_read_plan(addresses, address_profile=_client_address_profile(client))
     return await _read_named_with_plan(client, plan)
 
 
@@ -422,7 +421,7 @@ def read_named_sync(
     addresses: list[str],
 ) -> dict[str, int | float | bool]:
     """Synchronously read a mixed logical snapshot by address string."""
-    plan = _compile_read_plan(addresses, family=_client_address_profile(client))
+    plan = _compile_read_plan(addresses, address_profile=_client_address_profile(client))
     return _read_named_with_plan_sync(client, plan)
 
 
@@ -440,14 +439,14 @@ async def write_named(
     ``D50.3`` updates one bit inside one word. Direct bit devices such as
     ``M1000`` are normalized to ``"BIT"`` writes.
     """
-    family = _client_address_profile(client)
+    address_profile = _client_address_profile(client)
     for address, value in updates.items():
         base, dtype, bit_idx = _parse_address(address)
         if dtype == "BIT_IN_WORD":
-            _validate_bit_in_word_target(address, _parse_device_for_family(base, family))
+            _validate_bit_in_word_target(address, _parse_device_for_address_profile(base, address_profile))
             await write_bit_in_word(client, base, bit_idx or 0, bool(value))
         else:
-            device = _parse_device_for_family(base, family)
+            device = _parse_device_for_address_profile(base, address_profile)
             resolved_dtype = _resolve_dtype_for_address(address, device, dtype, bit_idx)
             _validate_long_timer_entry(address, device, resolved_dtype)
             await write_typed(client, base, resolved_dtype, value)
@@ -458,14 +457,14 @@ def write_named_sync(
     updates: dict[str, int | float | bool],
 ) -> None:
     """Synchronously write a mixed logical snapshot by address string."""
-    family = _client_address_profile(client)
+    address_profile = _client_address_profile(client)
     for address, value in updates.items():
         base, dtype, bit_idx = _parse_address(address)
         if dtype == "BIT_IN_WORD":
-            _validate_bit_in_word_target(address, _parse_device_for_family(base, family))
+            _validate_bit_in_word_target(address, _parse_device_for_address_profile(base, address_profile))
             write_bit_in_word_sync(client, base, bit_idx or 0, bool(value))
         else:
-            device = _parse_device_for_family(base, family)
+            device = _parse_device_for_address_profile(base, address_profile)
             resolved_dtype = _resolve_dtype_for_address(address, device, dtype, bit_idx)
             _validate_long_timer_entry(address, device, resolved_dtype)
             write_typed_sync(client, base, resolved_dtype, value)
@@ -497,15 +496,10 @@ def _parse_address(address: str) -> tuple[str, str, int | None]:
 def _effective_address_profile(
     *,
     plc_profile: object | None = None,
-    family: object | None = None,
 ) -> object | None:
-    if plc_profile is not None and family is not None:
-        raise ValueError("Pass either plc_profile or family, not both.")
     if plc_profile is not None:
         defaults = _resolve_plc_profile_defaults(plc_profile)
         return None if defaults is None else defaults.address_profile
-    if family is not None:
-        return _normalize_plc_profile_hint(family)
     return None
 
 
@@ -513,7 +507,6 @@ def parse_address(
     address: str | DeviceRef,
     *,
     plc_profile: object | None = None,
-    family: object | None = None,
 ) -> SlmpAddress:
     """Parse public SLMP helper-layer address notation.
 
@@ -525,10 +518,10 @@ def parse_address(
         text = str(address)
         return SlmpAddress(text=text, base_device=text, dtype="U")
 
-    effective_family = _effective_address_profile(plc_profile=plc_profile, family=family)
+    effective_address_profile = _effective_address_profile(plc_profile=plc_profile)
     raw_text = address.strip()
     base, dtype, bit_index = _parse_address(raw_text)
-    device = _parse_device_for_family(base, effective_family)
+    device = _parse_device_for_address_profile(base, effective_address_profile)
     canonical_base = str(device)
 
     if bit_index is not None:
@@ -561,12 +554,11 @@ def try_parse_address(
     address: str | DeviceRef,
     *,
     plc_profile: object | None = None,
-    family: object | None = None,
 ) -> SlmpAddress | None:
     """Return parsed address information, or ``None`` when parsing fails."""
 
     try:
-        return parse_address(address, plc_profile=plc_profile, family=family)
+        return parse_address(address, plc_profile=plc_profile)
     except Exception:
         return None
 
@@ -575,14 +567,13 @@ def format_address(
     address: SlmpAddress | str | DeviceRef,
     *,
     plc_profile: object | None = None,
-    family: object | None = None,
 ) -> str:
     """Return canonical public SLMP address text."""
 
     if not isinstance(address, SlmpAddress):
-        return parse_address(address, plc_profile=plc_profile, family=family).text
+        return parse_address(address, plc_profile=plc_profile).text
 
-    canonical_base = normalize_address(address.base_device, plc_profile=plc_profile, family=family)
+    canonical_base = normalize_address(address.base_device, plc_profile=plc_profile)
     if address.dtype == "BIT_IN_WORD":
         if address.bit_index is None or not 0 <= address.bit_index <= 15:
             raise ValueError("bit-in-word address requires bit_index 0-F")
@@ -598,7 +589,6 @@ def normalize_address(
     address: str | DeviceRef,
     *,
     plc_profile: object | None = None,
-    family: object | None = None,
 ) -> str:
     """Return the canonical helper-layer form of one SLMP device address.
 
@@ -610,14 +600,14 @@ def normalize_address(
     if not isinstance(address, str):
         return str(address)
 
-    effective_family = _effective_address_profile(plc_profile=plc_profile, family=family)
+    effective_address_profile = _effective_address_profile(plc_profile=plc_profile)
 
     text = address.strip()
     if ":" not in text and "." not in text:
-        return str(parse_device(text, plc_profile=effective_family))
+        return str(parse_device(text, plc_profile=effective_address_profile))
 
     base, dtype, bit_index = _parse_address(text)
-    canonical_base = str(parse_device(base, plc_profile=effective_family))
+    canonical_base = str(parse_device(base, plc_profile=effective_address_profile))
     if bit_index is not None:
         return f"{canonical_base}.{bit_index:X}"
     if ":" in text:
@@ -791,7 +781,7 @@ def _read_long_family_value_sync(
 def _compile_read_plan(
     addresses: list[str],
     *,
-    family: object | None = None,
+    address_profile: object | None = None,
 ) -> _ReadPlan:
     entries: list[_ReadPlanEntry] = []
     word_devices: list[DeviceRef] = []
@@ -801,7 +791,7 @@ def _compile_read_plan(
 
     for address in addresses:
         base, dtype, bit_index = _parse_address(address)
-        device = _parse_device_for_family(base, family)
+        device = _parse_device_for_address_profile(base, address_profile)
         dtype = _resolve_dtype_for_address(address, device, dtype, bit_index)
         _validate_long_timer_entry(address, device, dtype)
         batch_kind: str | None = None
@@ -1105,7 +1095,7 @@ async def poll(
 
     The address list is compiled once and reused for every cycle.
     """
-    plan = _compile_read_plan(addresses, family=_client_address_profile(client))
+    plan = _compile_read_plan(addresses, address_profile=_client_address_profile(client))
     while True:
         yield await _read_named_with_plan(client, plan)
         await asyncio.sleep(interval)
@@ -1117,7 +1107,7 @@ def poll_sync(
     interval: float,
 ) -> Iterator[dict[str, int | float | bool]]:
     """Synchronously yield mixed snapshots at a fixed interval."""
-    plan = _compile_read_plan(addresses, family=_client_address_profile(client))
+    plan = _compile_read_plan(addresses, address_profile=_client_address_profile(client))
     while True:
         yield _read_named_with_plan_sync(client, plan)
         time.sleep(interval)

{slmp_connect_python-1.0.0 → slmp_connect_python-1.0.1/slmp_connect_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slmp-connect-python
-Version: 1.0.0
+Version: 1.0.1
 Summary: SLMP Connect Python: client library for MELSEC SLMP binary communication
 Author: fa-yoshinobu
 License-Expression: MIT