ikkToolKit 0.0.0__py3-none-any.whl

ikkToolKit/ComPort/SerialBase.py

@@ -0,0 +1,105 @@
+# シリアル通信の基本クラス
+# 現時点ではバーコードリーダー向け用途に対応しているのでRead可能であるがWriteは未実装
+# 自動接続などの機能は継承先で実装してね！
+import logging
+import serial
+import serial.tools.list_ports
+import time
+from typing import Optional,Dict
+
+logger = logging.getLogger(__name__)
+
+class SerialBase:
+    #--------------------------------------------------------------------------
+    def __init__(self):
+        '''コンストラクタ
+        '''
+        self._sp: Optional[serial.Serial] = None  # シリアルオブジェクト
+    #--------------------------------------------------------------------------
+    @staticmethod
+    def PortLists() -> Dict[str, str]:
+        """有効なシリアルポート一覧を辞書にして返す
+        Returns:
+            {ポート名: デバイス説明文} の辞書
+        """
+        ports = serial.tools.list_ports.comports()
+        return {port.device: port.description for port in ports}
+    #--------------------------------------------------------------------------
+    @property
+    def BaudRate(self) -> int:
+        """現在のボーレート"""
+        return self._sp.baudrate if self._sp else 0
+    @property
+    def portName(self) -> Optional[str]:
+        """接続しているデバイスの名称"""
+        return self._sp.name if self._sp else None
+    @property
+    def deviceName(self) -> Optional[str]:
+        """接続しているデバイスの説明文（description）"""
+        if not self._sp:
+            return None
+        # 現在のポート名と一致する ListPortInfo を探して description を返す
+        for info in serial.tools.list_ports.comports():
+            if info.device == self._sp.port:
+                return info.description
+        return None
+    #==========================================================================
+    def close(self):
+        sp = self._sp
+        self._sp = None
+        if not sp:
+            return
+        try:
+            if sp.is_open:
+                sp.close()
+        except Exception as exc:
+            logger.warning("serial close failed during shutdown: %s", exc)
+    #==========================================================================
+    def open(self, port: str, baudrate: int = 9600) -> bool:
+        try:
+            self._sp = serial.Serial(
+                port=port,
+                baudrate=baudrate,
+                timeout=1,
+                write_timeout=1
+            )
+            # ⭐ 重要
+            self._sp.reset_input_buffer()
+            self._sp.reset_output_buffer()
+            # ⭐ CH340安定化
+            self._sp.dtr = False
+            time.sleep(0.05)
+            self._sp.dtr = True
+            return True
+        except serial.SerialException:
+            return False
+    #==========================================================================
+    def readLine(self, encoding: str = "utf-8", errors: str = "ignore") -> str:
+        '''シリアルから1行読み取る（ブロッキング）'''
+        sp = self._sp
+        if not sp or not sp.is_open:
+            raise serial.SerialException("Port not open")
+        buffer = bytearray()
+        while True:
+            ch = sp.read(1)
+            if ch == b'\n' or ch == b'\r':  # 改行コードで終了
+                break
+            if ch == b'':
+                return ""
+            buffer += ch
+        return buffer.decode(encoding=encoding, errors=errors).strip()
+###############################################################################
+# テスト
+###############################################################################
+if __name__ == "__main__":
+    reader = SerialBase()
+    print("******** 有効なシリアルポート一覧 *********")
+    print(SerialBase.PortLists())
+    print("*****************************************")
+    #キーワードで開くテスト（環境に合わせてキーワードを変更してください）
+    for port in SerialBase.PortLists().keys():
+        if reader.open(port=port):
+            print(f"👌成功：{reader.portName} :{reader.deviceName} ")
+            reader.close()
+        else:
+            print("❌オープン失敗")

ikkToolKit/ComPort/SerialReceiver.py

@@ -0,0 +1,278 @@
+# シリアル通信を継承したバーコードリーダークラス
+# 受信特化で、接続監視と自動再接続機能を備える
+# コードの内容などのユーザーごとの都合は継承先で実装してね！
+import threading
+import logging 
+import time
+import serial
+from typing import Callable, Optional
+
+try:
+    from .SerialBase import SerialBase
+except ImportError:
+    from SerialBase import SerialBase
+
+logger = logging.getLogger(__name__)
+
+class SerialReceiver(SerialBase):
+    #==========================================================================
+    def __init__(self, keyword: str, baudrate: int = 9600, debug: bool = False, encoding: str = "utf-8", decode_errors: str = "ignore", port_selector: Optional[Callable[[list[dict[str, str]]], Optional[str]]] = None):
+        '''コンストラクタ'''
+        super().__init__()
+        self._keyword = keyword
+        self._bordRrate = baudrate
+        self._debugMode = debug
+        self._encoding = encoding
+        self._decodeErrors = decode_errors
+        self._portSelector = port_selector
+        self._preferredPort = ""
+        self._preferredVid = ""
+        self._preferredPid = ""
+        self._preferredSerialNumber = ""
+        self._lastSelectionPromptAt = 0.0
+        self._lastSelectionSignature: tuple[tuple[str, str, str, str], ...] = tuple()
+        self.on_receive: Optional[Callable[[str], None]] = None
+        self.on_connected: Optional[Callable[[], None]] = None
+        self.on_disconnected: Optional[Callable[[], None]] = None
+        self._running: bool = False
+        self._thread: Optional[threading.Thread] = None
+        self._log:Optional[logging.Logger] = None
+    def setLogger(self, logger: logging.Logger):
+        self._log = logger
+    def setPortSelector(self, selector: Optional[Callable[[list[dict[str, str]]], Optional[str]]]) -> None:
+        self._portSelector = selector
+    def setPreferredDevice(self, port: Optional[str] = None, vid: Optional[str] = None, pid: Optional[str] = None, serial_number: Optional[str] = None) -> None:
+        self._preferredPort = (port or "").strip().upper()
+        self._preferredVid = (vid or "").strip().upper()
+        self._preferredPid = (pid or "").strip().upper()
+        self._preferredSerialNumber = (serial_number or "").strip()
+    #==========================================================================
+    @property
+    def BaudRate(self) -> int:
+        """現在のボーレート"""
+        return self._bordRrate
+    @property
+    def Encoding(self) -> str:
+        """受信デコードに使う文字コード"""
+        return self._encoding
+    #==========================================================================
+    def start(self):
+        '''接続監視'''
+        # すでに動いてるなら何もしない
+        if self._running:
+            return
+        self._running = True
+        # デバッグモードならキー入力ループ、通常モードなら接続監視ループをスレッドで開始
+        if self._debugMode:
+            self._thread = threading.Thread(
+                target=self._debugLoop,
+                daemon=True
+            )
+        else:
+            self._thread = threading.Thread(
+                target=self._loopRx,
+                daemon=True
+            )
+        self._thread.start()
+    #================================================================
+    def stop(self):
+        self._running = False
+        self.close()
+        if self._thread:
+            self._thread.join(timeout=1.2)
+            if self._thread.is_alive():
+                logger.warning("SerialReceiver thread did not stop within timeout")
+            self._thread = None
+    #----------------------------------------------------------------
+    def _debugLoop(self):
+        key_map = self._getDebugKeyMap()
+        print("=== DEBUG MODE ===")
+        if self.on_connected:
+            self.on_connected() #デバッグモードでも接続イベントは発火させる
+        for k, v in key_map.items():
+            print(f"{k} → {v}")
+        print("q → quit debug")
+        while self._running:
+            try:
+                key = input("> ").strip().lower()
+                if key == "q":
+                    break
+                if key in key_map:
+                    self._emitBarcode(key_map[key])
+            except (KeyboardInterrupt, EOFError):
+                break
+        self._running = False
+    #----------------------------------------------------------------
+    def _getDebugKeyMap(self):
+        """デバッグモードで模擬するメッセージと発動キーのマップ。継承先で上書きする(これはひな形)
+        """
+        return {
+            "a": "AAAA",
+            "b": "BBBB",
+            "c": "CCCC",
+            "1": "1111",
+            "2": "2222",
+            "3": "3333",
+        }
+    #----------------------------------------------------------------
+    def _emitBarcode(self, code: str):
+        if self.on_receive: #受信ベント発火🔥
+            self.on_receive(code)
+    #----------------------------------------------------------------
+    @staticmethod
+    def _portInfoToCandidate(port_info) -> dict[str, str]:
+        vid = getattr(port_info, "vid", None)
+        pid = getattr(port_info, "pid", None)
+        return {
+            "port": str(getattr(port_info, "device", "") or ""),
+            "description": str(getattr(port_info, "description", "") or ""),
+            "manufacturer": str(getattr(port_info, "manufacturer", "") or ""),
+            "product": str(getattr(port_info, "product", "") or ""),
+            "serial_number": str(getattr(port_info, "serial_number", "") or ""),
+            "vid": f"{vid:04X}" if vid is not None else "",
+            "pid": f"{pid:04X}" if pid is not None else "",
+        }
+    #----------------------------------------------------------------
+    def _keywordMatches(self, port_info) -> bool:
+        description = str(getattr(port_info, "description", "") or "")
+        return bool(self._keyword) and self._keyword.upper() in description.upper()
+    #----------------------------------------------------------------
+    def _isFallbackCandidate(self, port_info) -> bool:
+        return False
+    #----------------------------------------------------------------
+    def _matchesPreferredIdentity(self, port_info) -> bool:
+        candidate = self._portInfoToCandidate(port_info)
+        candidate_serial = candidate["serial_number"]
+        if self._preferredSerialNumber and candidate_serial == self._preferredSerialNumber:
+            return True
+        if self._preferredVid and self._preferredPid:
+            return candidate["vid"] == self._preferredVid and candidate["pid"] == self._preferredPid
+        return False
+    #----------------------------------------------------------------
+    def _notifyConnected(self) -> None:
+        if self.on_connected:
+            self.on_connected()
+    #----------------------------------------------------------------
+    def _tryOpenPort(self, port_info) -> bool:
+        if self.open(port_info.device, self._bordRrate):
+            self._preferredPort = str(port_info.device).upper()
+            self._notifyConnected()
+            return True
+        return False
+    #----------------------------------------------------------------
+    def _requestFallbackSelection(self, candidates: list[dict[str, str]]) -> Optional[str]:
+        if not self._portSelector or not candidates:
+            return None
+        signature = tuple(
+            (candidate["port"], candidate["vid"], candidate["pid"], candidate["serial_number"])
+            for candidate in candidates
+        )
+        now = time.monotonic()
+        if signature == self._lastSelectionSignature and (now - self._lastSelectionPromptAt) < 10.0:
+            return None
+        self._lastSelectionSignature = signature
+        self._lastSelectionPromptAt = now
+        try:
+            selected_port = self._portSelector(candidates)
+            return selected_port.strip().upper() if selected_port else None
+        except Exception:
+            logger.exception("COMポート選択コールバックで例外発生")
+            return None
+    #----------------------------------------------------------------
+    def _connectAvailablePort(self) -> bool:
+        port_infos = list(serial.tools.list_ports.comports())
+        if not port_infos:
+            return False
+
+        tried_ports: set[str] = set()
+
+        def try_open(predicate: Callable[[object], bool]) -> bool:
+            for port_info in port_infos:
+                port_name = str(getattr(port_info, "device", "") or "").upper()
+                if not port_name or port_name in tried_ports:
+                    continue
+                if not predicate(port_info):
+                    continue
+                tried_ports.add(port_name)
+                if self._tryOpenPort(port_info):
+                    return True
+            return False
+
+        if try_open(self._matchesPreferredIdentity):
+            return True
+
+        if self._preferredPort:
+            preferred_port = self._preferredPort.upper()
+            for port_info in port_infos:
+                port_name = str(getattr(port_info, "device", "") or "").upper()
+                if port_name != preferred_port:
+                    continue
+                tried_ports.add(port_name)
+                if self._tryOpenPort(port_info):
+                    return True
+                break
+
+        if try_open(self._keywordMatches):
+            return True
+
+        fallback_candidates = [
+            self._portInfoToCandidate(port_info)
+            for port_info in port_infos
+            if str(getattr(port_info, "device", "") or "").upper() not in tried_ports and self._isFallbackCandidate(port_info)
+        ]
+        selected_port = self._requestFallbackSelection(fallback_candidates)
+        if not selected_port:
+            return False
+
+        for port_info in port_infos:
+            port_name = str(getattr(port_info, "device", "") or "").upper()
+            if port_name != selected_port:
+                continue
+            return self._tryOpenPort(port_info)
+        return False
+    #----------------------------------------------------------------
+    def _loopRx(self):
+        """仮想COMの受信ループ"""
+        while self._running:
+            # --- 未接続なら接続試行 ---
+            if not self._sp or not self._sp.is_open:
+                connected = self._connectAvailablePort()
+                if not connected:
+                    time.sleep(1)
+                    logger.debug("Waiting for device...")
+                continue
+            # --- 接続中は受信処理 ---
+            try:
+                line = self.readLine(encoding=self._encoding, errors=self._decodeErrors)
+                # logger.debug(f"Received line: {repr(line)}")
+                if line:
+                    if self.on_receive:
+                        self.on_receive(line) #受信ベント発火🔥
+            except serial.SerialException:
+                self.close()
+                if self.on_disconnected:
+                    self.on_disconnected()
+        # ループ終了時安全クローズ
+        self.close()
+###############################################################################
+# テスト
+###############################################################################
+if __name__ == "__main__":
+    #コマンド引数 d があればデバッグモードで起動
+    import sys
+    debug_mode = "d" in sys.argv
+
+    #キーワードとデバッグモードを指定
+    sr = SerialReceiver(keyword="CH340", debug=debug_mode)
+    #イベントハンドラの設定(動作確認用のプリント)
+    sr.on_connected = lambda: print("🔗Device connected.")
+    sr.on_disconnected = lambda: print("⚡Device disconnected.")
+    sr.on_receive = lambda code: print(f"📥 Recive: {repr(code)}", flush=True)
+    sr.start()
+    print("Press Ctrl+C to stop...")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("Stopping...")
+        sr.stop()

ikkToolKit/ComPort/__init__.py

@@ -0,0 +1,5 @@
+"""シリアル通信モジュール"""
+from .SerialBase import SerialBase
+from .SerialReceiver import SerialReceiver
+
+__all__ = ["SerialBase", "SerialReceiver"]

ikkToolKit/FileSelector/FileSelector.py

@@ -0,0 +1,62 @@
+import tkinter as tk
+from tkinter import filedialog
+from pathlib import Path
+
+class FileSelector:
+    """ファイル選択クラス（UIツールキットに依存しない）"""
+    def __init__(self, base_folder: str, extensions: list[str]):
+        """
+        Args:
+            base_folder: 初期表示フォルダ
+            extensions: 拡張子リスト ['*.csv', '*.txt']
+        """
+        self._base_folder = base_folder
+        self._extensions = extensions
+        self._last_folder = base_folder
+    
+    @property
+    def base_folder(self) -> str:
+        return self._base_folder
+    @base_folder.setter
+    def base_folder(self, folder: str):
+        self._base_folder = folder
+    def select(self, root=None) -> str | None:
+        """
+        ファイル選択ダイアログを表示
+        Args:
+            root: 外部から渡された tk.Tk インスタンス（オプション）
+                  None の場合は自前で生成・破棄
+        Returns:
+            選択ファイルのフルパス、キャンセルの場合は None
+        """
+        # 外部から root が渡されたかチェック
+        if root is None:
+            root = tk.Tk()
+            root.withdraw()
+            should_destroy = True
+        else:
+            should_destroy = False
+        try:
+            filetypes = [("対象ファイル", " ".join(self._extensions)), 
+                        ("すべてのファイル", "*.*")]
+            file_path = filedialog.askopenfilename(
+                initialdir=self._last_folder,
+                title="ファイルを選択",
+                filetypes=filetypes
+            )
+            if file_path:
+                self._last_folder = str(Path(file_path).parent)
+                return file_path
+            else:
+                return None
+        finally:
+            if should_destroy:
+                root.destroy()
+###############################################################################
+#
+###############################################################################
+if __name__ == "__main__":
+    # ikkToolKit 側（root不要）
+    selector = FileSelector("C:\\", ["*.pdf"])
+    file_path = selector.select()  # 自前で root を生成・破棄
+    print("Selected file:", file_path)

ikkToolKit/FileSelector/__init__.py

@@ -0,0 +1,3 @@
+from .FileSelector import FileSelector
+
+__all__ = ["FileSelector"]

ikkToolKit/HID/HidCodeReader.py

@@ -0,0 +1,130 @@
+import keyboard
+import threading
+import time
+from typing import Callable, Optional
+
+class HidCodeReader:
+    def __init__(self, debug=False, prefix='pause', suffix='right'):
+        """
+        HIDバーコードリーダーの読み取りクラス
+        :param debug: デバッグモードの有無 (デフォルト: False)
+        :param prefix: 読み取り開始のキー名 (デフォルト: 'pause')
+        :param suffix: 読み取り終了のキー名 (デフォルト: 'right')
+        """
+        self._debugMode = debug
+        self.prefix = prefix
+        self.suffix = suffix
+        self.on_begin_capture: Optional[Callable] = None
+        self.on_receive: Optional[Callable[[str], None]] = None
+        self._buffer = []
+        self._is_reading = False
+        self._is_running = False
+        
+    def _handle_key_event(self, event):
+        """内部のキーボードイベントハンドラ"""
+        if event.event_type != keyboard.KEY_DOWN:
+            return
+
+        # 1. プレフィックスを検知
+        if event.name == self.prefix:
+            self._is_reading = True
+            self._buffer = []
+            if self.on_begin_capture: #キャプチャ開始イベントが登録されていれば呼び出す
+                self.on_begin_capture()
+            return
+
+        # 2. サフィックスを検知
+        elif event.name == self.suffix:
+            if self._is_reading:
+                barcode_data = "".join(self._buffer)
+                self._is_reading = False
+                self._buffer = []
+                
+                # 上位モジュールへイベント（コールバック）を通知
+                if self.on_receive and barcode_data:
+                    self.on_receive(barcode_data)
+            return
+
+        # 3. データ蓄積
+        elif self._is_reading:
+            if len(event.name) == 1:
+                self._buffer.append(event.name)
+    #----------------------------------------------------------------
+    def start(self):
+        """バックグラウンドでバーコードリーダーの監視を開始する"""
+        if self._is_running:
+            return  # 既に実行中の場合は何もしない
+        self._is_running = True
+        # デバッグモードならキー入力ループ、通常モードなら接続監視ループをスレッドで開始
+        if self._debugMode:
+            self._thread = threading.Thread(
+                target=self._debugLoop,
+                daemon=True
+            )
+            self._thread.start()
+        else:        
+            # keyboard.hook はグローバルでフックするため、
+            # startメソッドを実行するだけでバックグラウンド（別スレッド）でOS全体の入力を監視し始めます
+            keyboard.hook(self._handle_key_event)
+    #----------------------------------------------------------------
+    def stop(self):
+        """監視を停止する"""
+        if not self._is_running:
+            return
+        self._is_running = False
+        if self._debugMode:
+            # デバッグスレッドの終了を待つ
+            if hasattr(self, '_thread') and self._thread.is_alive():
+                self._thread.join(timeout=2)
+        else:
+            # フックを解除して停止
+            keyboard.unhook(self._handle_key_event)
+            self._buffer = []
+    #----------------------------------------------------------------
+    def _debugLoop(self):
+        key_map = self._getDebugKeyMap()
+        print("=== DEBUG MODE ===")
+        for k, v in key_map.items():
+            print(f"{k} → {v}")
+        print("q → quit debug")
+        while self._is_running:
+            try:
+                key = input("> ").strip().lower()
+                if key == "q":
+                    break
+                if key in key_map:
+                    self._emitBarcode(key_map[key])
+            except (KeyboardInterrupt, EOFError):
+                break
+        self._is_running = False
+    #----------------------------------------------------------------
+    def _emitBarcode(self, code: str):
+        if self.on_receive: #受信ベント発火🔥
+            self.on_receive(code)
+    #----------------------------------------------------------------
+    def _getDebugKeyMap(self):
+        """デバッグモードで模擬するメッセージと発動キーのマップ。継承先で上書きする(これはひな形)
+        """
+        return {
+            "a": "AAAA",
+            "b": "BBBB",
+            "c": "CCCC",
+            "1": "1111",
+            "2": "2222",
+            "3": "3333",
+        }        
+###############################################################################
+# テスト
+###############################################################################
+if __name__ == "__main__":
+
+    reader = HidCodeReader()
+    reader.on_receive = lambda code: print(f"📥 Recive: {repr(code)}", flush=True)
+    reader.start()
+
+    try:
+        while True:
+            time.sleep(1)  # メインスレッドをアイドル状態にしておく
+    except KeyboardInterrupt:
+        print("Stopping...")
+        reader.stop()

ikkToolKit/HID/__init__.py

@@ -0,0 +1,4 @@
+"""シリアル通信モジュール"""
+from .HidCodeReader import HidCodeReader
+
+__all__ = ["HidCodeReader"]