Update turbowarp-server/qr-converter.py

turbowarp-server/qr-converter.py

@@ -1,290 +1,197 @@
-import os
 import time
 import random
-import threading
-from io import BytesIO
-
 import requests
 from PIL import Image
+from io import BytesIO
+import scratchcommunication
 
-# 既存コードを流用
+# --- 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:
-        v = tw.get_variable(name=name, name_literal=False)
-        return None if v is None else str(v)
-    except Exception:
+        value = tw.get_variable(name=name, name_literal=False)
+        print(f"[GET] Variable '{name}' = {value[:50]}..." if value and len(value) > 50 else f"[GET] Variable '{name}' = {value}")
+        return value
+    except Exception as e:
+        print(f"[ERROR] Failed to get variable '{name}': {e}")
         return None
 
 def set_var(name, value):
     try:
-        return tw.set_variable(name=name, value=str(value), name_literal=False)
-    except Exception:
+        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
 
-
-# ========= 設定 =========
-API_URL = "https://izuemon-pixart-alpha-pixart-sigma-xl-2-1024-ms.hf.space/gen"
-N_CHARS_PATH = "turbowarp-server/n-chars.txt"
-
-NEGATIVE_PROMPT = "nsfw, low quality"
-WIDTH = 352
-HEIGHT = 352
-CFG = 0
-SEED_RANDOM = True
-SAMPLING_STEPS = 2
-
-OUT_SIZE = (90, 90)
-PACKET_DATA_LIMIT = 9998   # 「10」を除いたデータ部の上限として扱う
-POLL_INTERVAL = 0.5        # クラウド変数の連続送信を防ぐ
-ACK_VALUE = "11"           # Scratch側が既読にした合図
-BUSY_LOCK = "1"
-FREE_LOCK = "0"
-
-
-# ========= 文字対応表 =========
-def load_n_chars(path: str):
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"n-chars.txt が見つかりません: {path}")
-
-    with open(path, "r", encoding="utf-8") as f:
-        chars = [line.rstrip("\n") for line in f]
-
-    if len(chars) < 100:
-        raise ValueError("n-chars.txt は最低 100 行必要です（00〜99）。")
-    return chars[:100]
-
-N_CHARS = load_n_chars(N_CHARS_PATH)
-N_CHARS_MAP = {f"{i:02d}": ch for i, ch in enumerate(N_CHARS)}
-N_CHARS_REV = {ch: f"{i:02d}" for i, ch in enumerate(N_CHARS)}
-
-
-def decode_numeric_text(encoded: str) -> str:
-    """
-    00〜99 の2桁列を文字列に戻す。
-    例: '000102' -> ['00','01','02']
-    """
-    encoded = "" if encoded is None else str(encoded)
-    encoded = "".join(ch for ch in encoded if ch.isdigit())
-
-    if len(encoded) % 2 != 0:
-        encoded = encoded[:-1]  # 末尾が余ったら切り捨て
-
-    out = []
-    for i in range(0, len(encoded), 2):
-        key = encoded[i:i+2]
-        out.append(N_CHARS_MAP.get(key, ""))
-    return "".join(out)
-
-
-def encode_text_to_numeric(text: str) -> str:
-    """
-    文字列 -> 00〜99 の列
-    """
-    result = []
-    for ch in str(text):
-        if ch not in N_CHARS_REV:
-            raise ValueError(f"対応表にない文字です: {repr(ch)}")
-        result.append(N_CHARS_REV[ch])
-    return "".join(result)
-
-
-# ========= Cloud 値の正規化 =========
-def normalize_value(v):
-    if v is None:
-        return ""
-    return str(v).strip()
-
-
-def get_n1():
-    return normalize_value(get_var("n1"))
-
-def get_n0():
-    return normalize_value(get_var("n0"))
-
-def set_n1(v):
-    return set_var("n1", v)
-
-def set_n0(v):
-    return set_var("n0", v)
-
-
-# ========= 画像生成 =========
-def fetch_generated_image(prompt: str) -> Image.Image:
+# --- 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 decode_prompt(encoded_str):
+    """クラウド変数の数字列を元にプロンプト文字列に復号"""
+    chars = []
+    for i in range(0, len(encoded_str), 2):
+        idx = int(encoded_str[i:i+2])
+        if idx < len(n_chars):
+            chars.append(n_chars[idx])
+    decoded = "".join(chars)
+    print(f"[DECODE] Encoded prompt -> '{decoded[:50]}...'")
+    return decoded
+
+def rgb_to_scratch_number(rgb):
+    """RGBを0-999999の10進数に変換"""
+    r, g, b = rgb
+    return f"{r:03}{g:03}{b:03}"
+
+def generate_image(prompt):
+    """APIから352x352の画像生成"""
+    seed = random.randint(0, 999999)
+    print(f"[INFO] Generating image with prompt: '{prompt[:50]}...', seed={seed}")
     params = {
         "prompt": prompt,
-        "negative_prompt": NEGATIVE_PROMPT,
-        "seed": random.randint(0, 2**31 - 1) if SEED_RANDOM else 0,
-        "randomize_seed": "true" if SEED_RANDOM else "false",
-        "width": WIDTH,
-        "height": HEIGHT,
-        "guidance_scale": CFG,
-        "num_inference_steps": SAMPLING_STEPS,
+        "negative_prompt": "nsfw, low quality",
+        "width": 352,
+        "height": 352,
+        "num_inference_steps": 2,
+        "guidance_scale": 0,
+        "seed": seed,
+        "randomize_seed": "true"
     }
-
-    r = requests.get(API_URL, params=params, timeout=300)
-    r.raise_for_status()
-
-    # 生画像データを想定
-    img = Image.open(BytesIO(r.content)).convert("RGB")
+    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_to_90(img: Image.Image) -> Image.Image:
-    return img.resize(OUT_SIZE, Image.Resampling.LANCZOS)
-
-
-def rgb_to_6digits(r: int, g: int, b: int) -> str:
-    """
-    RGB を 6桁の10進数に変換。
-    仕様が曖昧なため、各チャンネルを 0〜99 に線形変換して 2桁ずつ連結する。
-    """
-    rr = round(r * 99 / 255)
-    gg = round(g * 99 / 255)
-    bb = round(b * 99 / 255)
-    return f"{rr:02d}{gg:02d}{bb:02d}"
-
-
-def image_to_payload(img: Image.Image) -> str:
-    """
-    90x90 の画像を左上から走査し、
-    '10' + 90*90個の6桁数値 を返す。
-    """
-    pixels = img.load()
-    w, h = img.size
-    parts = ["10"]
-
-    for y in range(h):
-        for x in range(w):
-            r, g, b = pixels[x, y]
-            parts.append(rgb_to_6digits(r, g, b))
-
-    return "".join(parts)
-
-
-# ========= パケット送信 =========
-def split_packets(data: str, limit: int = PACKET_DATA_LIMIT):
-    return [data[i:i+limit] for i in range(0, len(data), limit)]
-
-
-def wait_for_ack():
-    while True:
-        time.sleep(POLL_INTERVAL)
-        v = get_n1()
-        if v == ACK_VALUE:
-            return
-        # 事故防止: 途中で n1 が空や想定外に戻った場合は少し待つ
-        # 必要ならここでエラー処理にしてもよい
-
-
-def send_packets(data_with_prefix: str):
-    packets = split_packets(data_with_prefix, PACKET_DATA_LIMIT)
-
-    for idx, packet in enumerate(packets, start=1):
-        # 送信開始
-        set_n1("10" + packet)
-
-        # Scratch側が既読にして "11" にするまで待つ
-        wait_for_ack()
-
-        # 次の通信へ行く前に少し空ける
-        time.sleep(POLL_INTERVAL)
-
-    # 全送信完了
-    set_n0(FREE_LOCK)
-
-
-# ========= メイン処理 =========
-def process_incoming_value(raw_value: str):
-    """
-    n1 の 3文字目以降をデコードして prompt として使う。
-    もしここで「ID -> prompt」変換を入れたい場合は、
-    decode_numeric_text の結果を ID として別処理に差し替えてください。
-    """
-    raw_value = normalize_value(raw_value)
-
-    if len(raw_value) < 3:
-        return
-
-    kind = raw_value[0]   # 0: ID送信系 / 1: レスポンス系
-    read_flag = raw_value[1]
-    payload = raw_value[2:]
-
-    # 今回は「送られてきたものをデコードしたもの」を prompt として使う
-    decoded_prompt = decode_numeric_text(payload)
-
-    # 必要なら kind / read_flag を使って分岐できる
-    # kind == "0" -> 依頼受信
-    # kind == "1" -> 返信など
-    _ = read_flag
-
-    # 画像生成
-    img = fetch_generated_image(decoded_prompt)
-
-    # 90x90 に縮小
-    img = resize_to_90(img)
-
-    # 送信用の数値列へ変換
-    payload_90 = image_to_payload(img)
-
-    # 送信前にロックをかける
-    set_n0(BUSY_LOCK)
-
-    # パケット分割送信
-    send_packets(payload_90)
-
-
-def server_loop():
-    last_n1 = None
-
-    while True:
-        try:
-            current_n1 = get_n1()
-
-            # 変化を検知したときだけ処理
-            if current_n1 and current_n1 != last_n1:
-                last_n1 = current_n1
-
-                # 他ユーザー使用中なら何もしない
-                if get_n0() == BUSY_LOCK:
-                    time.sleep(POLL_INTERVAL)
-                    continue
-
-                # n1 の先頭が 0 のときだけ受信処理
-                if current_n1.startswith("0"):
-                    # まず使用中にする
-                    set_n0(BUSY_LOCK)
-
-                    # 既読化の扱いが必要ならここで Scratch 側仕様に合わせて書き換え
-                    # 例: 受信確認として n1 を一度 "11" にする場合はここで行う
-                    # set_n1(ACK_VALUE)
-
-                    process_incoming_value(current_n1)
-
-                    # process_incoming_value 側で最後に n0=0 に戻す
-                else:
-                    time.sleep(POLL_INTERVAL)
-
-            time.sleep(POLL_INTERVAL)
-
-        except Exception:
-            # 例外時はロック解除して継続
-            try:
-                set_n0(FREE_LOCK)
-            except Exception:
-                pass
-            time.sleep(POLL_INTERVAL)
-
-
-if __name__ == "__main__":
-    # 初期化
-    set_n0(FREE_LOCK)
-    # n1 は必要ならここで初期値を入れる
-    set_n1("0")
-
-    server_loop()
+def resize_and_encode(img):
+    """90x90にリサイズして数字列に変換"""
+    img = img.resize((90, 90))
+    print("[INFO] Resized image to 90x90.")
+    encoded = ""
+    for y in range(90):
+        for x in range(90):
+            encoded += rgb_to_scratch_number(img.getpixel((x, y)))
+    print(f"[INFO] Image encoded to string of length {len(encoded)}.")
+    return "10" + encoded  # 先頭に "10"
+
+def split_packets(data, max_length=9998):
+    """10000文字制限に合わせて分割（先頭 '10' 含む）"""
+    packets = []
+    idx = 0
+    while idx < len(data):
+        chunk = data[idx:idx + max_length]
+        packets.append(chunk)
+        idx += max_length
+    print(f"[INFO] Data split into {len(packets)} packet(s).")
+    return packets
+
+# --- メインループ ---
+print("[INFO] Starting main loop...")
+last_processed_id = ""  # 最後に処理したIDを記録
+
+while True:
+    try:
+        n1 = get_var("n1")
+        n0 = get_var("n0")
+        
+        # n1が存在し、長さが3以上で、先頭が"0"（新規リクエスト）
+        if n1 and len(n1) >= 3 and n1[0] == "0":
+            user_id = n1[1:3]  # ユーザーID（2桁）
+            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 this request, marking as read...")
+                # 既読マークをつける（先頭を"01"に変更）
+                marked_as_read = "01" + request_data[2:]
+                set_var("n1", marked_as_read)
+                time.sleep(0.1)
+                continue
+            
+            # n0が利用可能かチェック
+            if n0 == "0" or n0 is None:
+                print("[INFO] n0 is free, starting processing...")
+                
+                # 処理中フラグをセット
+                set_var("n0", "1")
+                
+                # リクエストを既読にする（先頭を"01"に変更）
+                marked_as_read = "01" + request_data[2:]
+                set_var("n1", marked_as_read)
+                
+                # プロンプトをデコード（先頭の"0" + ユーザーID(2桁)を除去）
+                encoded_prompt = request_data[3:]
+                prompt = decode_prompt(encoded_prompt)
+                
+                # 画像生成
+                img = generate_image(prompt)
+                scratch_data = resize_and_encode(img)
+                
+                # パケット分割
+                packets = split_packets(scratch_data)
+                
+                # 最初のパケットを送信
+                for i, pkt in enumerate(packets):
+                    print(f"[INFO] Sending packet {i+1}/{len(packets)}")
+                    set_var("n1", pkt)
+                    
+                    if i < len(packets) - 1:
+                        # 次のパケットのACKを待つ
+                        print("[INFO] Waiting for ACK '11'...")
+                        ack_timeout = 0
+                        while ack_timeout < 50:  # 5秒タイムアウト
+                            current_n1 = get_var("n1")
+                            if current_n1 == "11":
+                                print("[INFO] Received ACK")
+                                break
+                            time.sleep(0.1)
+                            ack_timeout += 1
+                        
+                        if ack_timeout >= 50:
+                            print("[ERROR] ACK timeout")
+                            set_var("n0", "0")
+                            break
+                    else:
+                        # 最後のパケットは完了を待つ
+                        print("[INFO] Waiting for completion '99'...")
+                        complete_timeout = 0
+                        while complete_timeout < 50:
+                            current_n1 = get_var("n1")
+                            if current_n1 == "99":
+                                print("[INFO] Received completion signal")
+                                break
+                            time.sleep(0.1)
+                            complete_timeout += 1
+                
+                # 完了後リセット
+                print("[INFO] Transmission complete. Resetting n0.")
+                set_var("n0", "0")
+                last_processed_id = request_data  # 処理済みとして記録
+                
+            else:
+                print("[INFO] n0 is busy, waiting...")
+        else:
+            # 何もしない
+            pass
+            
+    except Exception as e:
+        print(f"[ERROR] Exception in main loop: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    time.sleep(0.2)