Update turbowarp-server/qr-converter.py

turbowarp-server/qr-converter.py

@@ -6,7 +6,8 @@ import time
 import random
 import math
 
-PROJECT_ID = "1293416663"
+# プロジェクトID
+PROJECT_ID = 1293416663
 
 # 接続設定
 tw = scratchcommunication.TwCloudConnection(
@@ -17,220 +18,273 @@ tw = scratchcommunication.TwCloudConnection(
 
 # n-chars.txtの読み込み
 def load_char_map():
+    """n-chars.txtから文字マッピングを読み込む"""
     char_map = {}
-    with open("turbowarp-server/n-chars.txt", "r", encoding="utf-8") as f:
-        lines = f.readlines()
-        for i, line in enumerate(lines):
-            char = line.strip()
-            if char:  # 空行をスキップ
-                char_map[char] = str(i).zfill(2)  # 00-99の2桁に
-    return char_map
-
-def encode_prompt(prompt, char_map):
+    try:
+        with open("turbowarp-server/n-chars.txt", "r", encoding="utf-8") as f:
+            chars = f.read().strip().split("\n")
+            for i, char in enumerate(chars):
+                char_map[char] = str(i).zfill(2)  # 00, 01, 02...
+                char_map[str(i).zfill(2)] = char  # 逆引きも保存
+        return char_map
+    except Exception as e:
+        print(f"文字マップ読み込みエラー: {e}")
+        return {}
+
+CHAR_MAP = load_char_map()
+
+def encode_prompt(prompt):
     """プロンプトを数字列にエンコード"""
     encoded = []
     for char in prompt:
-        if char in char_map:
-            encoded.append(char_map[char])
+        if char in CHAR_MAP:
+            encoded.append(CHAR_MAP[char])
         else:
-            # 未知の文字はスペース(または適当な文字)として処理
-            encoded.append(char_map.get(" ", "00"))
+            encoded.append("99")  # 不明な文字は99
     return "".join(encoded)
 
-def decode_prompt(encoded_str, char_map):
+def decode_prompt(encoded):
     """数字列をプロンプトにデコード"""
-    # 文字マップの逆引きを作成
-    reverse_map = {v: k for k, v in char_map.items()}
     decoded = []
-    for i in range(0, len(encoded_str), 2):
-        code = encoded_str[i:i+2]
-        if code in reverse_map:
-            decoded.append(reverse_map[code])
+    for i in range(0, len(encoded), 2):
+        code = encoded[i:i+2]
+        if code in CHAR_MAP:
+            decoded.append(CHAR_MAP[code])
         else:
             decoded.append("?")
     return "".join(decoded)
 
 def get_var(name):
-    """クラウド変数の取得（安全版）"""
+    """クラウド変数の値を取得（安全版）"""
     try:
         return tw.get_variable(name=name, name_literal=False)
     except Exception:
         return None
 
 def set_var(name, value):
-    """クラウド変数の設定（安全版）"""
+    """クラウド変数の値を設定（安全版）"""
     try:
         return tw.set_variable(name=name, value=value, name_literal=False)
     except Exception:
         return None
 
-def generate_image(prompt):
-    """画像生成APIを呼び出し、画像データを取得"""
-    url = "https://izuemon-pixart-alpha-pixart-sigma-xl-2-1024-ms.hf.space/gen"
-    
-    params = {
-        "prompt": prompt,
-        "negative_prompt": "nsfw, low quality",
-        "seed": random.randint(0, 2**32 - 1),
-        "randomize_seed": "true",
-        "width": 352,
-        "height": 352,
-        "guidance_scale": 0,  # CFG=0
-        "num_inference_steps": 2
-    }
+def wait_for_var_change(var_name, expected_prefix=None, timeout=30):
+    """変数の変更を待機"""
+    start_time = time.time()
+    last_value = get_var(var_name)
     
+    while time.time() - start_time < timeout:
+        current_value = get_var(var_name)
+        if current_value != last_value:
+            if expected_prefix is None or str(current_value).startswith(expected_prefix):
+                return current_value
+            last_value = current_value
+        time.sleep(0.1)
+    return None
+
+def generate_image(prompt, negative_prompt="nsfw, low quality"):
+    """画像生成APIを呼び出し"""
     try:
-        response = requests.get(url, params=params, timeout=30)
+        # ランダムシードを生成
+        seed = random.randint(0, 2**32 - 1)
+        
+        params = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "seed": seed,
+            "randomize_seed": "false",
+            "width": 352,
+            "height": 352,
+            "guidance_scale": 0.0,  # CFG=0
+            "num_inference_steps": 2
+        }
+        
+        response = requests.get(
+            "https://izuemon-pixart-alpha-pixart-sigma-xl-2-1024-ms.hf.space/gen",
+            params=params,
+            timeout=60
+        )
+        
         if response.status_code == 200:
-            return Image.open(BytesIO(response.content))
+            return response.content
         else:
-            print(f"画像生成エラー: {response.status_code}")
+            print(f"画像生成APIエラー: {response.status_code}")
             return None
+            
     except Exception as e:
-        print(f"画像生成���外: {e}")
+        print(f"画像生成エラー: {e}")
         return None
 
-def resize_image(image, size=(90, 90)):
+def resize_image(image_data, size=(90, 90)):
     """画像をリサイズ"""
-    return image.resize(size, Image.Resampling.LANCZOS)
+    try:
+        img = Image.open(BytesIO(image_data))
+        img = img.resize(size, Image.Resampling.LANCZOS)
+        return img
+    except Exception as e:
+        print(f"リサイズエラー: {e}")
+        return None
 
-def image_to_rgb_string(image):
-    """画像をRGB文字列に変換（000000-999999の形式）"""
+def image_to_rgb_string(img):
+    """画像をRGB値の文字列に変換（000000-999999形式）"""
     pixels = []
-    width, height = image.size
+    width, height = img.size
     
     for y in range(height):
         for x in range(width):
-            r, g, b = image.getpixel((x, y))
-            # RGBを6桁の数値に変換（例: 255,255,255 -> 255255255）
-            rgb_value = f"{r:03d}{g:03d}{b:03d}"
-            pixels.append(rgb_value)
+            r, g, b = img.getpixel((x, y))[:3]
+            # RGBを6桁の数字に変換（000000-999999）
+            rgb_value = r * 10000 + g * 100 + b
+            pixels.append(str(rgb_value).zfill(6))
     
     return "".join(pixels)
 
-def send_packets(data, prefix="10"):
+def send_packets(data, var_name="n1"):
     """データをパケットに分割して送信"""
-    max_chars = 9998  # 10000文字制限のため
+    # パケットサイズ（n1のプレフィックス"10"を除く）
+    packet_size = 9998 - 2  # "10"分を引く
     
-    # データを分割
-    packets = []
-    for i in range(0, len(data), max_chars):
-        packets.append(data[i:i+max_chars])
+    # パケット数
+    total_packets = math.ceil(len(data) / packet_size)
     
-    total_packets = len(packets)
+    for i in range(total_packets):
+        start = i * packet_size
+        end = min((i + 1) * packet_size, len(data))
+        packet_data = data[start:end]
+        
+        # パケット番号を付与（2桁）
+        packet_num = str(i + 1).zfill(2)
+        packet_value = f"10{packet_num}{packet_data}"
+        
+        # 送信
+        set_var(var_name, packet_value)
+        print(f"パケット {i+1}/{total_packets} 送信: {len(packet_data)}文字")
+        
+        # 次のパケットの前に既読を待機
+        if i < total_packets - 1:
+            # "11"に変更されるのを待機
+            start_wait = time.time()
+            while True:
+                current = get_var(var_name)
+                if current and str(current).startswith("11"):
+                    print(f"パケット {i+1} 既読確認")
+                    break
+                if time.time() - start_wait > 30:
+                    print("既読待機タイムアウト")
+                    break
+                time.sleep(0.1)
+            
+            # 0.5秒間隔
+            time.sleep(0.5)
     
-    for packet_index, packet_data in enumerate(packets):
-        # パケット番号を付加（例: 10_0, 10_1...）
-        packet_value = f"{prefix}_{packet_index}"
-        
-        # データを送信（クラウド変数は文字列として扱う）
-        set_var(packet_value, packet_data)
-        
-        # 次のパケットを送信するまで待機（ack確認）
-        while True:
-            ack = get_var("11")
-            if ack == str(packet_index):
-                break
-            time.sleep(0.1)
+    return total_packets
+
+def process_request(received_value):
+    """受信したデータを処理"""
+    try:
+        # 受信データ: "0[ID][encoded_prompt]"
+        # 先頭が'0'か確認
+        value_str = str(received_value)
+        if not value_str.startswith('0'):
+            print(f"無効なデータ形式: {value_str[:10]}...")
+            return
+        
+        # ID抽出（2桁）
+        if len(value_str) < 3:
+            print("IDが不足しています")
+            return
+        
+        user_id = value_str[1:3]
+        encoded_prompt = value_str[3:]
+        
+        print(f"処理開始 - ID: {user_id}, エンコード長: {len(encoded_prompt)}")
+        
+        # プロンプトをデコード
+        prompt = decode_prompt(encoded_prompt)
+        print(f"デコードされたプロンプト: {prompt}")
+        
+        # 画像生成
+        print("画像生成中...")
+        image_data = generate_image(prompt)
+        if not image_data:
+            print("画像生成失敗")
+            return
         
-        # 0.5秒間隔を空ける
-        time.sleep(0.5)
+        # リサイズ
+        print("画像リサイズ中...")
+        resized_img = resize_image(image_data)
+        if not resized_img:
+            print("リサイズ失敗")
+            return
+        
+        # RGB文字列に変換
+        print("RGB変換中...")
+        rgb_string = image_to_rgb_string(resized_img)
+        print(f"RGB文字列長: {len(rgb_string)}文字")
+        
+        # パケット送信
+        print("パケット送信開始...")
+        packet_count = send_packets(rgb_string)
+        print(f"送信完了: {packet_count}パケット")
+        
+        return True
+        
+    except Exception as e:
+        print(f"処理エラー: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """メインループ"""
+    print("サーバー起動...")
+    print("プロジェクトID:", PROJECT_ID)
     
-    # 送信完了を通知
-    set_var("10_complete", "1")
-    time.sleep(0.5)
-
-def process_request():
-    """メイン処理：リクエストの監視と処理"""
-    char_map = load_char_map()
-    last_n1_value = None
+    # 初期化
+    set_var("n0", "0")
+    set_var("n1", "00")
     
-    print("サーバー起動完了。リクエストを監視中...")
+    print("待機中...")
     
     while True:
         try:
-            # n1の監視
-            n1_value = get_var("n1")
+            # n1の変更を監視
+            n1_value = wait_for_var_change("n1", expected_prefix="0", timeout=5)
             
-            if n1_value is not None and n1_value != last_n1_value:
-                # 文字列として扱う
-                n1_str = str(n1_value)
+            if n1_value is not None:
+                # 使用中フラグを立てる
+                set_var("n0", "1")
+                print(f"受信データ検出: {str(n1_value)[:50]}...")
+                
+                # 既読にする（n1を"1x"に変更）
+                # 元の値から既読フラグを立てる
+                current_n1 = str(n1_value)
+                if len(current_n1) >= 2:
+                    read_value = "1" + current_n1[1:]
+                    set_var("n1", read_value)
+                    print(f"既読設定: {read_value}")
+                
+                # リクエスト処理
+                success = process_request(n1_value)
                 
-                # 有効な形式かチェック（少なくとも2文字以上）
-                if len(n1_str) >= 2:
-                    msg_type = n1_str[0]  # 0: ID送信, 1: レスポンス返信
-                    
-                    # 受信メッセージ（ID送信）の場合
-                    if msg_type == "0":
-                        print("リクエストを受信しました")
-                        
-                        # ビジー状態に設定
-                        set_var("n0", "1")
-                        time.sleep(0.1)
-                        
-                        try:
-                            # IDを取得（3桁目以降）
-                            encoded_data = n1_str[2:] if len(n1_str) > 2 else ""
-                            
-                            if encoded_data:
-                                # 既読に設定
-                                # 2文字目を1に変更（既読）
-                                new_n1 = "1" + n1_str[1:2] + encoded_data
-                                set_var("n1", new_n1)
-                                time.sleep(0.1)
-                                
-                                # プロンプトをデコード
-                                prompt = decode_prompt(encoded_data, char_map)
-                                print(f"プロンプト: {prompt}")
-                                
-                                # 画像生成
-                                print("画像生成中...")
-                                image = generate_image(prompt)
-                                
-                                if image:
-                                    # リサイズ
-                                    resized = resize_image(image, (90, 90))
-                                    
-                                    # RGB文字列に変換
-                                    rgb_data = image_to_rgb_string(resized)
-                                    
-                                    # データの先頭に "10" を付加
-                                    full_data = "10" + rgb_data
-                                    
-                                    # パケット分割送信
-                                    print("データ送信中...")
-                                    send_packets(full_data)
-                                    
-                                    print("処理完了")
-                                else:
-                                    print("画像生成に失敗しました")
-                                    # エラー通知
-                                    set_var("10_error", "1")
-                                    time.sleep(0.5)
-                            else:
-                                print("データが空です")
-                                
-                        except Exception as e:
-                            print(f"処理中エラー: {e}")
-                            set_var("10_error", "1")
-                            time.sleep(0.5)
-                        
-                        finally:
-                            # ビジー状態を解除
-                            set_var("n0", "0")
-                            time.sleep(0.1)
+                if success:
+                    print("処理完了")
+                else:
+                    print("処理失敗")
                 
-                last_n1_value = n1_value
+                # 使用中フラグを解除
+                set_var("n0", "0")
+                print("待機再開...")
             
-            # 適度な間隔で監視
             time.sleep(0.1)
             
         except KeyboardInterrupt:
-            print("\nサーバーを停止します")
+            print("\nサーバー停止")
+            set_var("n0", "0")
             break
         except Exception as e:
-            print(f"監視ループエラー: {e}")
+            print(f"メインループエラー: {e}")
             time.sleep(1)
 
 if __name__ == "__main__":
-    process_request()
+    main()