Update turbowarp-server/qr-converter.py

turbowarp-server/qr-converter.py

@@ -1,281 +1,236 @@
-import time
-import random
+import scratchcommunication
 import requests
 from PIL import Image
 from io import BytesIO
-import scratchcommunication
+import time
+import random
+import math
 
-# --- Scratchクラウド接続 ---
 PROJECT_ID = "1293416663"
-print(f"[INFO] Connecting to Scratch project {PROJECT_ID}...")
+
+# 接続設定
 tw = scratchcommunication.TwCloudConnection(
     project_id=PROJECT_ID,
     username="server",
     contact_info="contact"
 )
-print("[INFO] Connected successfully.")
 
-def get_var(name):
-    try:
-        value = tw.get_variable(name=name, name_literal=False)
-        
-        # デバッグ用に生の値を出力
-        print(f"[DEBUG] Raw value of '{name}': {value} (type: {type(value).__name__})")
-        
-        # Noneの場合は"0"として扱う
-        if value is None:
-            print(f"[WARNING] Variable '{name}' is None, treating as '0'")
-            return "0"
-        
-        # 様々な型を文字列に変換
-        if isinstance(value, (int, float)):
-            value = str(int(value))
-            print(f"[GET] Variable '{name}' converted from number to string: '{value}'")
-        elif not isinstance(value, str):
-            value = str(value)
-            print(f"[GET] Variable '{name}' converted from {type(value).__name__} to string: '{value}'")
-        
-        # 表示用に切り詰め
-        display_value = value[:50] + "..." if len(value) > 50 else value
-        print(f"[GET] Variable '{name}' = '{display_value}'")
-        return value
-    except Exception as e:
-        print(f"[ERROR] Failed to get variable '{name}': {e}")
-        return "0"
+# n-chars.txtの読み込み
+def load_char_map():
+    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 set_var(name, value):
-    try:
-        tw.set_variable(name=name, value=value, name_literal=False)
-        print(f"[SET] Variable '{name}' = '{value[:50]}...'" if len(value) > 50 else f"[SET] Variable '{name}' = '{value}'")
-        return True
-    except Exception as e:
-        print(f"[ERROR] Failed to set variable '{name}': {e}")
-        return None
-
-# --- n-chars.txt の読み込み ---
-print("[INFO] Loading n-chars.txt...")
-with open("turbowarp-server/n-chars.txt", "r", encoding="utf-8") as f:
-    n_chars = [line.strip() for line in f]
-print(f"[INFO] Loaded {len(n_chars)} characters.")
-
-def encode_prompt(prompt):
-    """プロンプト文字列を数字列にエンコード（半角スペースは96として特別処理）"""
-    encoded = ""
+def encode_prompt(prompt, char_map):
+    """プロンプトを数字列にエンコード"""
+    encoded = []
     for char in prompt:
-        if char == " ":
-            encoded += "96"
+        if char in char_map:
+            encoded.append(char_map[char])
         else:
-            try:
-                idx = n_chars.index(char)
-                encoded += f"{idx:02d}"
-            except ValueError:
-                print(f"[WARNING] Character '{char}' not found in n_chars, skipping")
-                continue
-    print(f"[ENCODE] Prompt encoded to length {len(encoded)}")
-    return encoded
+            # 未知の文字はスペース(または適当な文字)として処理
+            encoded.append(char_map.get(" ", "00"))
+    return "".join(encoded)
 
-def decode_prompt(encoded_str):
-    """クラウド変数の数字列を元にプロンプト文字列に復号（96は半角スペースとして処理）"""
-    chars = []
-    i = 0
-    while i < len(encoded_str):
-        idx = int(encoded_str[i:i+2])
-        if idx == 96:
-            chars.append(" ")
-        elif idx < len(n_chars):
-            chars.append(n_chars[idx])
+def decode_prompt(encoded_str, char_map):
+    """数字列をプロンプトにデコード"""
+    # 文字マップの逆引きを作成
+    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])
         else:
-            print(f"[WARNING] Invalid index {idx} at position {i}")
-        i += 2
-    decoded = "".join(chars)
-    print(f"[DECODE] Encoded prompt -> '{decoded[:50]}...'")
-    return decoded
+            decoded.append("?")
+    return "".join(decoded)
 
-def rgb_to_scratch_number(rgb):
-    """RGBを6桁の10進数に変換 (R:00-99, G:00-99, B:00-99)"""
-    r, g, b = rgb
-    # 各色を0-99の範囲に収める（元が0-255の場合）
-    r_scaled = int(r * 99 / 255)
-    g_scaled = int(g * 99 / 255)
-    b_scaled = int(b * 99 / 255)
-    return f"{r_scaled:02d}{g_scaled:02d}{b_scaled:02d}"
+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から352x352の画像生成"""
-    seed = random.randint(0, 999999)
-    print(f"[INFO] Generating image with prompt: '{prompt[:50]}...', seed={seed}")
+    """画像生成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,
-        "num_inference_steps": 2,
-        "guidance_scale": 0,
-        "seed": seed,
-        "randomize_seed": "true"
+        "guidance_scale": 0,  # CFG=0
+        "num_inference_steps": 2
     }
-    resp = requests.get("https://izuemon-pixart-alpha-pixart-sigma-xl-2-1024-ms.hf.space/gen", params=params)
-    resp.raise_for_status()
-    img = Image.open(BytesIO(resp.content))
-    print(f"[INFO] Image generated: size={img.size}, mode={img.mode}")
-    return img
-
-def resize_and_encode(img):
-    """90x90にリサイズして6桁の数字列に変換（各ピクセル6桁）"""
-    img = img.resize((90, 90))
-    print("[INFO] Resized image to 90x90.")
     
-    encoded = ""
-    total_pixels = 0
+    try:
+        response = requests.get(url, params=params, timeout=30)
+        if response.status_code == 200:
+            return Image.open(BytesIO(response.content))
+        else:
+            print(f"画像生成エラー: {response.status_code}")
+            return None
+    except Exception as e:
+        print(f"画像生成例外: {e}")
+        return None
+
+def resize_image(image, size=(90, 90)):
+    """画像をリサイズ"""
+    return image.resize(size, Image.Resampling.LANCZOS)
+
+def image_to_rgb_string(image):
+    """画像をRGB文字列に変換（000000-999999の形式）"""
+    pixels = []
+    width, height = image.size
     
-    for y in range(90):
-        for x in range(90):
-            pixel = img.getpixel((x, y))
-            # RGB値を取得（RGBAの場合はRGBのみ使用）
-            if len(pixel) >= 3:
-                r, g, b = pixel[:3]
-            else:
-                r, g, b = pixel, pixel, pixel
-            encoded += rgb_to_scratch_number((r, g, b))
-            total_pixels += 1
+    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)
     
-    expected_length = total_pixels * 6
-    print(f"[INFO] Encoded {total_pixels} pixels to string of length {len(encoded)} (expected: {expected_length})")
-    return encoded
+    return "".join(pixels)
 
-def split_packets(data, max_length=9998):
-    """10000文字制限に合わせて分割（先頭 '10' 含む）"""
+def send_packets(data, prefix="10"):
+    """データをパケットに分割して送信"""
+    max_chars = 9998  # 10000文字制限のため
+    
+    # データを分割
     packets = []
-    idx = 0
-    total_length = len(data)
-    expected_packets = (total_length + max_length - 1) // max_length
+    for i in range(0, len(data), max_chars):
+        packets.append(data[i:i+max_chars])
     
-    while idx < len(data):
-        chunk = data[idx:idx + max_length]
-        packets.append(chunk)
-        idx += max_length
+    total_packets = len(packets)
     
-    print(f"[INFO] Data length: {total_length}, max packet size: {max_length}")
-    print(f"[INFO] Expected {expected_packets} packets, actual {len(packets)} packets")
-    return packets
-
-# --- メインループ ---
-print("[INFO] Starting main loop...")
-last_processed_id = ""
-
-# 初期化
-set_var("n0", "0")
-set_var("n1", "0")
-time.sleep(1)
-
-while True:
-    try:
-        n1 = get_var("n1")
-        n0 = get_var("n0")
+    for packet_index, packet_data in enumerate(packets):
+        # パケット番号を付加（例: 10_0, 10_1...）
+        packet_value = f"{prefix}_{packet_index}"
         
-        print(f"[DEBUG] n0='{n0}', n1='{n1[:30]}...' if n1 and len(n1)>30 else n1")
+        # データを送信（クラウド変数は文字列として扱う）
+        set_var(packet_value, packet_data)
         
-        is_n0_free = (n0 == "0")
-        print(f"[DEBUG] is_n0_free: {is_n0_free}")
+        # 次のパケットを送信するまで待機（ack確認）
+        while True:
+            ack = get_var("11")
+            if ack == str(packet_index):
+                break
+            time.sleep(0.1)
         
-        if n1 and len(n1) >= 3 and n1[0] == "0":
-            user_id = n1[1:3]
-            request_data = n1
-            
-            print(f"[INFO] Received request from user {user_id}")
-            print(f"[INFO] Request data length: {len(request_data)}")
-            
-            if request_data == last_processed_id:
-                print("[INFO] Already processed, marking as read...")
-                marked_as_read = "01" + request_data[2:]
-                set_var("n1", marked_as_read)
-                time.sleep(0.1)
-                continue
+        # 0.5秒間隔を空ける
+        time.sleep(0.5)
+    
+    # 送信完了を通知
+    set_var("10_complete", "1")
+    time.sleep(0.5)
+
+def process_request():
+    """メイン処理：リクエストの監視と処理"""
+    char_map = load_char_map()
+    last_n1_value = None
+    
+    print("サーバー起動完了。リクエストを監視中...")
+    
+    while True:
+        try:
+            # n1の監視
+            n1_value = get_var("n1")
             
-            if is_n0_free:
-                print("[INFO] n0 is free, starting processing...")
+            if n1_value is not None and n1_value != last_n1_value:
+                # 文字列として扱う
+                n1_str = str(n1_value)
                 
-                # 処理中フラグ
-                set_var("n0", "1")
-                
-                # リクエストを既読に
-                marked_as_read = "01" + request_data[2:]
-                set_var("n1", marked_as_read)
-                
-                # プロンプトをデコード
-                encoded_prompt = request_data[3:]
-                print(f"[INFO] Encoded prompt length: {len(encoded_prompt)}")
-                prompt = decode_prompt(encoded_prompt)
-                print(f"[INFO] Decoded prompt: '{prompt}'")
-                
-                # 画像生成とエンコード
-                img = generate_image(prompt)
-                scratch_data = resize_and_encode(img)
-                
-                # パケット分割
-                packets = split_packets(scratch_data)
-                print(f"[INFO] Will send {len(packets)} packets")
-                
-                # パケット送信
-                for i, pkt in enumerate(packets):
-                    packet_num = i + 1
-                    print(f"[INFO] Sending packet {packet_num}/{len(packets)} (size: {len(pkt)} chars)")
-                    
-                    # パケット送信
-                    set_var("n1", "10" + pkt)
+                # 有効な形式かチェック（少なくとも2文字以上）
+                if len(n1_str) >= 2:
+                    msg_type = n1_str[0]  # 0: ID送信, 1: レスポンス返信
                     
-                    if i < len(packets) - 1:
-                        # ACK待ち
-                        print(f"[INFO] Waiting for ACK for packet {packet_num}...")
-                        ack_timeout = 0
-                        ack_received = False
-                        while ack_timeout < 50:
-                            current_n1 = get_var("n1")
-                            if current_n1 == "11":
-                                print(f"[INFO] Received ACK for packet {packet_num}")
-                                ack_received = True
-                                break
-                            time.sleep(0.2)
-                            ack_timeout += 1
+                    # 受信メッセージ（ID送信）の場合
+                    if msg_type == "0":
+                        print("リクエストを受信しました")
                         
-                        if not ack_received:
-                            print(f"[ERROR] ACK timeout for packet {packet_num}")
-                            set_var("n0", "0")
-                            break
-                    else:
-                        # 完了待ち
-                        print("[INFO] Waiting for completion '99'...")
-                        complete_timeout = 0
-                        complete_received = False
-                        while complete_timeout < 50:
-                            current_n1 = get_var("n1")
-                            if current_n1 == "99":
-                                print("[INFO] Received completion signal")
-                                complete_received = True
-                                break
-                            time.sleep(0.2)
-                            complete_timeout += 1
+                        # ビジー状態に設定
+                        set_var("n0", "1")
+                        time.sleep(0.1)
                         
-                        if not complete_received:
-                            print("[ERROR] Completion timeout")
-                
-                # 完了
-                print("[INFO] Transmission complete. Resetting n0.")
-                set_var("n0", "0")
-                last_processed_id = request_data
-                print(f"[INFO] Set last_processed_id")
+                        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)
                 
-            else:
-                print("[INFO] n0 is busy, waiting...")
-        else:
-            if n1:
-                print(f"[DEBUG] n1 condition not met: first char='{n1[0] if n1 else 'None'}', length={len(n1) if n1 else 0}")
-            else:
-                print("[DEBUG] n1 is None or empty")
+                last_n1_value = n1_value
             
-    except Exception as e:
-        print(f"[ERROR] Exception in main loop: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    time.sleep(0.3)
+            # 適度な間隔で監視
+            time.sleep(0.1)
+            
+        except KeyboardInterrupt:
+            print("\nサーバーを停止します")
+            break
+        except Exception as e:
+            print(f"監視ループエラー: {e}")
+            time.sleep(1)
+
+if __name__ == "__main__":
+    process_request()