mms-mp-test 0.1.0__tar.gz

mms_mp_test-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: mms-mp-test
+Version: 0.1.0
+Summary: Load NumPy trajectories after detecting an Opal Kelly USB candidate
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+
+# mms-mp-test
+
+Linux USB 후보 장치를 확인한 뒤 사용자 NPZ 파일의 `trajectory` 배열을 읽습니다.
+
+```sh
+pip install mms-mp-test
+```
+
+```python
+from mp_test import load_trajectory
+
+trajectory = load_trajectory("franka_custom_tabletop_seed43_k1_configuration.npz")
+```
+
+`load_trajectory(npz_path: str | os.PathLike[str]) -> numpy.ndarray`의 경로는 필수입니다. 데이터 파일은 배포물에 포함하지 않습니다. 배열 값, shape, dtype을 그대로 반환하며 특정 크기를 요구하지 않습니다. 제공된 예제 파일은 `(17, 7)`의 `float64` 배열입니다.
+
+import 시 장치 검색이나 데이터 파일 읽기를 하지 않습니다. 호출할 때마다 Linux `/sys/bus/usb/devices`를 확인하며, 후보가 있을 때만 `numpy.load(..., allow_pickle=False)`로 파일을 읽고 닫습니다.
+
+후보 조건은 다음 중 하나입니다.
+
+- VID가 `151f`
+- 제조사 또는 제품명에 `Opal Kelly` 포함 (대소문자 무시)
+- 제품명이 `XEM7310` 또는 `XEM7360`으로 시작 (대소문자 무시)
+
+이는 USB 식별이며 FPGA 동작, 펌웨어, 로드된 설계를 검증하지 않습니다.
+
+| 예외 | 원인 |
+| --- | --- |
+| `RuntimeError` | Linux가 아님, USB 목록 접근 실패, 후보 없음 (메시지로 구분) |
+| `FileNotFoundError` | 후보 확인 후 지정한 파일이 없음 |
+| `KeyError` | `trajectory` 키 누락 |
+| `ValueError` | 잘못된 NPZ 또는 pickle이 필요한 배열 |
+
+파일 자체의 접근 권한 오류는 `PermissionError`로 전달됩니다.
+
+메타데이터는 계획대로 Python `>=3.8`, NumPy `>=1.26`입니다. 단, NumPy 1.26은 Python 3.9 이상이 필요하므로 Python 3.8에서는 이 의존성 조합을 설치할 수 없습니다. 실제 사용에는 Python 3.9 이상이 필요합니다.
+
+기존 소스 스크립트도 사용할 수 있습니다.
+
+```sh
+python3 detect_opalkelly.py --json
+```
+
+개발 및 배포 검증:
+
+```sh
+python3 -m venv .venv
+.venv/bin/python -m pip install -e . build twine
+.venv/bin/python -m unittest discover -v
+.venv/bin/python -m build
+.venv/bin/python -m twine check dist/*
+```
+
+라이선스와 작성자 정보는 제공되지 않아 지정하지 않았습니다. PyPI 게시 상태와 실물 장치 검증 여부는 `VALIDATION.md`를 참고하세요.

mms_mp_test-0.1.0/README.md

@@ -0,0 +1,54 @@
+# mms-mp-test
+
+Linux USB 후보 장치를 확인한 뒤 사용자 NPZ 파일의 `trajectory` 배열을 읽습니다.
+
+```sh
+pip install mms-mp-test
+```
+
+```python
+from mp_test import load_trajectory
+
+trajectory = load_trajectory("franka_custom_tabletop_seed43_k1_configuration.npz")
+```
+
+`load_trajectory(npz_path: str | os.PathLike[str]) -> numpy.ndarray`의 경로는 필수입니다. 데이터 파일은 배포물에 포함하지 않습니다. 배열 값, shape, dtype을 그대로 반환하며 특정 크기를 요구하지 않습니다. 제공된 예제 파일은 `(17, 7)`의 `float64` 배열입니다.
+
+import 시 장치 검색이나 데이터 파일 읽기를 하지 않습니다. 호출할 때마다 Linux `/sys/bus/usb/devices`를 확인하며, 후보가 있을 때만 `numpy.load(..., allow_pickle=False)`로 파일을 읽고 닫습니다.
+
+후보 조건은 다음 중 하나입니다.
+
+- VID가 `151f`
+- 제조사 또는 제품명에 `Opal Kelly` 포함 (대소문자 무시)
+- 제품명이 `XEM7310` 또는 `XEM7360`으로 시작 (대소문자 무시)
+
+이는 USB 식별이며 FPGA 동작, 펌웨어, 로드된 설계를 검증하지 않습니다.
+
+| 예외 | 원인 |
+| --- | --- |
+| `RuntimeError` | Linux가 아님, USB 목록 접근 실패, 후보 없음 (메시지로 구분) |
+| `FileNotFoundError` | 후보 확인 후 지정한 파일이 없음 |
+| `KeyError` | `trajectory` 키 누락 |
+| `ValueError` | 잘못된 NPZ 또는 pickle이 필요한 배열 |
+
+파일 자체의 접근 권한 오류는 `PermissionError`로 전달됩니다.
+
+메타데이터는 계획대로 Python `>=3.8`, NumPy `>=1.26`입니다. 단, NumPy 1.26은 Python 3.9 이상이 필요하므로 Python 3.8에서는 이 의존성 조합을 설치할 수 없습니다. 실제 사용에는 Python 3.9 이상이 필요합니다.
+
+기존 소스 스크립트도 사용할 수 있습니다.
+
+```sh
+python3 detect_opalkelly.py --json
+```
+
+개발 및 배포 검증:
+
+```sh
+python3 -m venv .venv
+.venv/bin/python -m pip install -e . build twine
+.venv/bin/python -m unittest discover -v
+.venv/bin/python -m build
+.venv/bin/python -m twine check dist/*
+```
+
+라이선스와 작성자 정보는 제공되지 않아 지정하지 않았습니다. PyPI 게시 상태와 실물 장치 검증 여부는 `VALIDATION.md`를 참고하세요.

mms_mp_test-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mms-mp-test"
+version = "0.1.0"
+description = "Load NumPy trajectories after detecting an Opal Kelly USB candidate"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["numpy>=1.26"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["mp_test*"]
+
+[tool.setuptools]
+include-package-data = false

mms_mp_test-0.1.0/setup.cfg

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

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

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: mms-mp-test
+Version: 0.1.0
+Summary: Load NumPy trajectories after detecting an Opal Kelly USB candidate
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.26
+
+# mms-mp-test
+
+Linux USB 후보 장치를 확인한 뒤 사용자 NPZ 파일의 `trajectory` 배열을 읽습니다.
+
+```sh
+pip install mms-mp-test
+```
+
+```python
+from mp_test import load_trajectory
+
+trajectory = load_trajectory("franka_custom_tabletop_seed43_k1_configuration.npz")
+```
+
+`load_trajectory(npz_path: str | os.PathLike[str]) -> numpy.ndarray`의 경로는 필수입니다. 데이터 파일은 배포물에 포함하지 않습니다. 배열 값, shape, dtype을 그대로 반환하며 특정 크기를 요구하지 않습니다. 제공된 예제 파일은 `(17, 7)`의 `float64` 배열입니다.
+
+import 시 장치 검색이나 데이터 파일 읽기를 하지 않습니다. 호출할 때마다 Linux `/sys/bus/usb/devices`를 확인하며, 후보가 있을 때만 `numpy.load(..., allow_pickle=False)`로 파일을 읽고 닫습니다.
+
+후보 조건은 다음 중 하나입니다.
+
+- VID가 `151f`
+- 제조사 또는 제품명에 `Opal Kelly` 포함 (대소문자 무시)
+- 제품명이 `XEM7310` 또는 `XEM7360`으로 시작 (대소문자 무시)
+
+이는 USB 식별이며 FPGA 동작, 펌웨어, 로드된 설계를 검증하지 않습니다.
+
+| 예외 | 원인 |
+| --- | --- |
+| `RuntimeError` | Linux가 아님, USB 목록 접근 실패, 후보 없음 (메시지로 구분) |
+| `FileNotFoundError` | 후보 확인 후 지정한 파일이 없음 |
+| `KeyError` | `trajectory` 키 누락 |
+| `ValueError` | 잘못된 NPZ 또는 pickle이 필요한 배열 |
+
+파일 자체의 접근 권한 오류는 `PermissionError`로 전달됩니다.
+
+메타데이터는 계획대로 Python `>=3.8`, NumPy `>=1.26`입니다. 단, NumPy 1.26은 Python 3.9 이상이 필요하므로 Python 3.8에서는 이 의존성 조합을 설치할 수 없습니다. 실제 사용에는 Python 3.9 이상이 필요합니다.
+
+기존 소스 스크립트도 사용할 수 있습니다.
+
+```sh
+python3 detect_opalkelly.py --json
+```
+
+개발 및 배포 검증:
+
+```sh
+python3 -m venv .venv
+.venv/bin/python -m pip install -e . build twine
+.venv/bin/python -m unittest discover -v
+.venv/bin/python -m build
+.venv/bin/python -m twine check dist/*
+```
+
+라이선스와 작성자 정보는 제공되지 않아 지정하지 않았습니다. PyPI 게시 상태와 실물 장치 검증 여부는 `VALIDATION.md`를 참고하세요.

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/mms_mp_test.egg-info/PKG-INFO
+src/mms_mp_test.egg-info/SOURCES.txt
+src/mms_mp_test.egg-info/dependency_links.txt
+src/mms_mp_test.egg-info/requires.txt
+src/mms_mp_test.egg-info/top_level.txt
+src/mp_test/__init__.py
+src/mp_test/_trajectory.py
+src/mp_test/_usb.py

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

@@ -0,0 +1 @@
+

mms_mp_test-0.1.0/src/mms_mp_test.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.26

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

@@ -0,0 +1 @@
+mp_test

mms_mp_test-0.1.0/src/mp_test/__init__.py

@@ -0,0 +1,5 @@
+"""Load a trajectory after detecting an Opal Kelly USB candidate."""
+
+from ._trajectory import load_trajectory
+
+__all__ = ['load_trajectory']

mms_mp_test-0.1.0/src/mp_test/_trajectory.py

@@ -0,0 +1,43 @@
+"""USB-gated trajectory loading, with no import-time I/O."""
+
+from __future__ import annotations
+
+import os
+import sys
+import zipfile
+import zlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import numpy as np
+
+from . import _usb
+
+
+def load_trajectory(npz_path: str | os.PathLike[str]) -> np.ndarray:
+    """Return the NPZ's trajectory unchanged after a fresh Linux USB check.
+
+    Raises RuntimeError for unsupported platforms, unreadable USB inventory,
+    or absent candidates. FileNotFoundError, KeyError, and ValueError describe
+    a missing file, missing trajectory, and invalid archive respectively.
+    """
+    if sys.platform != 'linux':
+        raise RuntimeError('USB detection requires Linux sysfs.')
+    try:
+        report = _usb.collect_usb()
+    except OSError as exc:
+        raise RuntimeError(f'Cannot read USB inventory: {exc}') from exc
+    if not report['opal_kelly_candidates']:
+        raise RuntimeError('No Opal Kelly USB candidate detected.')
+
+    import numpy as np
+
+    try:
+        with open(npz_path, 'rb') as stream:
+            archive = np.load(stream, allow_pickle=False)
+            if not isinstance(archive, np.lib.npyio.NpzFile):
+                raise ValueError('Expected an NPZ archive.')  # noqa: TRY004 -- file format error
+            with archive:
+                return archive['trajectory']
+    except (zipfile.BadZipFile, EOFError, zlib.error) as exc:
+        raise ValueError(f'Invalid NPZ archive: {exc}') from exc

mms_mp_test-0.1.0/src/mp_test/_usb.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Read-only USB inventory from Linux sysfs; no SDK or elevated privileges."""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+SYSFS_ROOT = Path('/sys/bus/usb/devices')
+KNOWN_MODEL = 'XEM7310-A200'
+KNOWN_SERIAL = '224800128A'
+LIMITATION = ('USB identification only; FPGA operation is not verified. '
+              'Firmware version and loaded FPGA design are unknown.')
+FIELDS = {
+    'manufacturer': 'manufacturer', 'product': 'product', 'serial': 'serial',
+    'vid': 'idVendor', 'pid': 'idProduct', 'bus_number': 'busnum',
+    'device_number': 'devnum', 'usb_version': 'version',
+    'speed_mbps': 'speed', 'device_version_raw': 'bcdDevice',
+}
+
+
+def read_attribute(path, warnings):
+    try:
+        return path.read_text(encoding='utf-8', errors='replace').strip() or None
+    except FileNotFoundError:
+        warnings.append(f'{path}: Attribute missing or device disconnected; unknown')
+    except OSError as exc:
+        warnings.append(f'{path}: Read failed ({exc}); Unknown')
+    return None
+
+
+def children(path, warnings):
+    try:
+        return sorted(path.iterdir(), key=lambda p: p.name)
+    except OSError as exc:
+        warnings.append(f'{path}: Directory listing failed ({exc})')
+        return []
+
+
+def endpoints(entries, warnings):
+    result = []
+    for entry in entries:
+        if not re.fullmatch(r'ep_[0-9a-fA-F]{2}', entry.name):
+            continue
+        endpoint = {'name': entry.name}
+        for key, attr in [('address', 'bEndpointAddress'),
+                          ('direction', 'direction'), ('transfer_type', 'type'),
+                          ('max_packet_size_raw', 'wMaxPacketSize')]:
+            endpoint[key] = read_attribute(entry / attr, warnings)
+        raw = endpoint['max_packet_size_raw']
+        try:
+            # Bits 10:0 are bytes per packet; upper bits encode transactions.
+            endpoint['max_packet_size_bytes'] = int(raw, 16) & 0x7ff if raw else None
+        except ValueError:
+            endpoint['max_packet_size_bytes'] = None
+            warnings.append(f'{entry}: Invalid wMaxPacketSize value {raw!r}')
+        result.append(endpoint)
+    return result
+
+
+def inspect_device(path):
+    warnings = []
+    device = {'sysfs_name': path.name}
+    device.update({key: read_attribute(path / attr, warnings)
+                   for key, attr in FIELDS.items()})
+    for key in ('vid', 'pid'):
+        if device[key]:
+            device[key] = device[key].lower()
+    reasons = []
+    if device['vid'] == '151f':
+        reasons.append('VID matches 151f')
+    for key in ('manufacturer', 'product'):
+        if 'opal kelly' in (device[key] or '').casefold():
+            reasons.append(f'{key} contains Opal Kelly')
+    product = (device['product'] or '').upper()
+    for prefix in ('XEM7310', 'XEM7360'):
+        if product.startswith(prefix):
+            reasons.append(f'Product starts with {prefix}')
+    device['is_opal_kelly_candidate'] = bool(reasons)
+    device['candidate_reasons'] = reasons
+    device['known_model_match'] = (None if device['product'] is None else
+                                    KNOWN_MODEL.casefold() in device['product'].casefold())
+    device['known_serial_match'] = (None if device['serial'] is None else
+                                     device['serial'] == KNOWN_SERIAL)
+    entries = children(path, warnings)
+    device['endpoints'] = endpoints(entries, warnings)
+    device['interfaces'] = []
+    for entry in entries:
+        if not re.fullmatch(r'\d+-[\d.]+:\d+\.\d+', entry.name):
+            continue
+        interface = {'name': entry.name,
+                     'class': read_attribute(entry / 'bInterfaceClass', warnings),
+                     'endpoints': endpoints(children(entry, warnings), warnings)}
+        device['interfaces'].append(interface)
+    device['warnings'] = warnings
+    return device
+
+
+def collect_usb(root=SYSFS_ROOT):
+    """Raise OSError only if the inventory root cannot be enumerated."""
+    entries = sorted(Path(root).iterdir(), key=lambda p: p.name)
+    devices = [inspect_device(path) for path in entries
+               if re.fullmatch(r'(?:usb\d+|\d+-\d+(?:\.\d+)*)', path.name)]
+    return {'devices': devices,
+            'opal_kelly_candidates': [d['sysfs_name'] for d in devices
+                                      if d['is_opal_kelly_candidate']],
+            'known_model': KNOWN_MODEL, 'known_serial': KNOWN_SERIAL,
+            'limitation': LIMITATION}
+
+
+def display(value):
+    if value is None:
+        return 'Unknown'
+    if isinstance(value, bool):
+        return 'Match' if value else 'No match'
+    return str(value)
+
+
+def print_endpoints(items, indent):
+    for ep in items:
+        print(f"{indent}Endpoint {display(ep['address'])}: "
+              f"direction={display(ep['direction'])}, type={display(ep['transfer_type'])}, "
+              f"max packet={display(ep['max_packet_size_bytes'])} bytes "
+              f"(raw={display(ep['max_packet_size_raw'])})")
+
+
+def print_report(report):
+    print(f"USB devices: {len(report['devices'])} (including root hubs)")
+    for device in report['devices']:
+        print(f"\n[{device['sysfs_name']}]")
+        for key in FIELDS:
+            value = display(device[key])
+            if key == 'speed_mbps' and device[key] is not None:
+                value += 'Mbps'
+            print(f'  {key}: {value}')
+        print(f"  Opal Kelly candidate: {'Yes' if device['is_opal_kelly_candidate'] else 'No'}")
+        print(f"  Detection reasons: {', '.join(device['candidate_reasons']) or 'None'}")
+        print(f"  {KNOWN_MODEL}: {display(device['known_model_match'])}")
+        print(f"  {KNOWN_SERIAL}: {display(device['known_serial_match'])}")
+        print_endpoints(device['endpoints'], '  ')
+        for interface in device['interfaces']:
+            print(f"  Interface {interface['name']}: class={display(interface['class'])}")
+            print_endpoints(interface['endpoints'], '    ')
+        for warning in device['warnings']:
+            print(f'  Warning: {warning}')
+    candidates = report['opal_kelly_candidates']
+    print(f"\nOpal Kelly candidate summary ({len(candidates)}): {', '.join(candidates) or 'None'}")
+    print(report['limitation'])
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--json', action='store_true', help='Print output as JSON')
+    args = parser.parse_args(argv)
+    try:
+        report = collect_usb()
+    except OSError as exc:
+        message = f'Cannot access USB inventory path: {exc}'
+        if args.json:
+            print(json.dumps({'error': message}, ensure_ascii=False))
+        else:
+            print(message, file=sys.stderr)
+        return 1
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print_report(report)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())