orange3-example 0.1.4__py3-none-any.whl

orange3_example-0.1.4.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: orange3-example
+Version: 0.1.4
+Summary: Orange3 LLM 기반 사용자 정의 예제 위젯입니다.
+Home-page: https://github.com/whyz-dev/Orange3-Widget
+Author: Gangjun Jo
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+Requires-Dist: Orange3>=3.32.0
+Requires-Dist: openai
+Requires-Dist: PyQt5
+Requires-Dist: python-dotenv
+Requires-Dist: opencv-python
+Requires-Dist: pyserial
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Orange3 Example Widgets
+
+Orange3를 위한 LLM 기반 사용자 정의 위젯 모음입니다.
+
+## 설치
+
+```bash
+pip install orange3-example
+```
+
+## 포함된 위젯
+
+### 1. LLM Transformer
+GPT API를 통해 입력 데이터를 변환하는 위젯입니다.
+
+**기능:**
+- 텍스트 데이터를 LLM으로 변환
+- 사용자 정의 프롬프트 입력
+- OpenAI API Key 설정
+
+**사용법:**
+1. 위젯을 Canvas에 추가
+2. OpenAI API Key 입력
+3. 프롬프트 입력
+4. 입력 데이터 연결 후 "변환 실행" 버튼 클릭
+
+### 2. Image LLM
+이미지와 텍스트를 입력받아 멀티모달 LLM으로 처리하는 위젯입니다.
+
+**기능:**
+- 이미지 + 텍스트 멀티모달 처리
+- GPT-4o 모델 사용
+- 실시간 이미지 표시
+
+**사용법:**
+1. 위젯을 Canvas에 추가
+2. OpenAI API Key 입력
+3. 이미지 데이터와 텍스트 데이터 연결
+4. 프롬프트 입력 후 자동 처리 또는 버튼 클릭
+
+### 3. Microbit Communicator
+시리얼 포트를 통해 마이크로비트로 데이터를 전송하는 위젯입니다.
+
+**기능:**
+- 시리얼 포트 연결
+- 텍스트 데이터 자동/수동 전송
+- 연결 상태 모니터링
+
+**사용법:**
+1. 위젯을 Canvas에 추가
+2. 포트 선택 및 연결
+3. 입력 텍스트 데이터 연결
+4. 자동 전송 활성화 또는 수동 전송 버튼 클릭
+
+### 4. Webcam Viewer
+웹캠을 실시간으로 표시하고 이미지를 캡쳐하는 위젯입니다.
+
+**기능:**
+- 실시간 웹캠 미리보기
+- 이미지 캡쳐 및 전송
+- 웹캠 시작/중지 제어
+
+**사용법:**
+1. 위젯을 Canvas에 추가
+2. "웹캠 시작" 버튼 클릭
+3. "이미지 캡쳐" 버튼으로 현재 프레임 캡쳐 및 전송
+
+## 요구사항
+
+- Python 3.6+
+- Orange3 >= 3.32.0
+- OpenAI API Key (LLM 위젯 사용 시)
+
+## 의존성
+
+- Orange3
+- openai
+- PyQt5
+- python-dotenv
+- opencv-python
+- pyserial
+
+## 라이선스
+
+MIT License
+
+## 저자
+
+Gangjun Jo
+
+## 링크
+
+- GitHub: https://github.com/whyz-dev/Orange3-Widget
+- PyPI: https://pypi.org/project/orange3-example/
+

orange3_example-0.1.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+orangecontrib/__init__.py,sha256=xKG6UHtaYxNc48-WwKZ8po0fBTYqoUgtEliazbxQWbQ,120
+orangecontrib/orange3example/__init__.py,sha256=M9j1NuexsmXRO0O_LLRNrLF7fEfPAHWIxm90hC6gV3I,27
+orangecontrib/orange3example/utils/llm.py,sha256=olx7B0mmnpavATZZ0s9-e0D6DL1Z-zcu-mGVviJi_iM,3208
+orangecontrib/orange3example/utils/microbit.py,sha256=-k8MSs-jK2ajREW1Lk32wEtG0VkgwrRuBd2tG9EiyfU,7081
+orangecontrib/orange3example/utils/webcam.py,sha256=P028DltxmUIQRHeeMFRY0vpZwuZdUjmMGZCSPgbtx6o,439
+orangecontrib/orange3example/widgets/__init__.py,sha256=6mCgjyLY-q-CoaipFKZXO0Hn51W904Xd7HqCdOfv_8s,131
+orangecontrib/orange3example/widgets/owimagellm.py,sha256=OmMteg2rCgTG6Ou-ZyPy4Gaa7WcXc-ouOFbLfuJ6NXY,9890
+orangecontrib/orange3example/widgets/owllmtransformer.py,sha256=EeDEF9mnd74ucHB86j3BVHf0bXaN-zppICCXA0ipjNo,4045
+orangecontrib/orange3example/widgets/owmicrobit.py,sha256=HnazGFItO8Vt0mzBPGndqrUFbK3Di9-OOx48vwpMWv4,7103
+orangecontrib/orange3example/widgets/owwebcam.py,sha256=dY_1fA4en1FMRcve0znqUgE2DrVXw3rXk_zQU9lWDUw,3585
+orange3_example-0.1.4.dist-info/METADATA,sha256=K0wXGtti7MubO0-1AhjZntD4Rm0JI-YdLxdxOdltRe8,2848
+orange3_example-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+orange3_example-0.1.4.dist-info/entry_points.txt,sha256=8BEmcvuTJCQU2ftCGkpAmEzybJtX5cJrg-keHi0eVXA,135
+orange3_example-0.1.4.dist-info/top_level.txt,sha256=Iut-JTfT11SZHHm77_ZeszD7pZDWXcTweCbvrJpqDyQ,14
+orange3_example-0.1.4.dist-info/RECORD,,

orange3_example-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

orange3_example-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[orange.widgets]
+Example Widgets = orangecontrib.orange3example.widgets
+
+[orange3.addon]
+orange3example = orangecontrib.orange3example

orange3_example-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+orangecontrib

orangecontrib/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+# in orangecontrib/__init__.py
+import pkg_resources
+pkg_resources.declare_namespace(__name__)

orangecontrib/orange3example/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+

orangecontrib/orange3example/utils/llm.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+import os
+from typing import Optional
+from openai import OpenAI
+from dotenv import load_dotenv
+
+class LLM:
+    """GPT API를 호출하는 클래스"""
+    def __init__(self, api_key: Optional[str] = None):
+        # 우선순위: 위젯 입력 키 > .env > 환경변수
+        load_dotenv()
+        effective_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.openai_client = OpenAI(api_key=effective_key)
+
+    def get_response(self, prompt, data_list):
+        """GPT의 응답을 받아서 그대로 반환"""
+        results = []
+
+        for data in data_list:
+            try:
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[
+                        {"role": "system", "content": prompt},
+                        {"role": "user", "content": str(data)},
+                    ],
+                    temperature=0,
+                )
+                results.append(response.choices[0].message.content.strip())
+
+            except Exception as e:
+                results.append(f"Error: {str(e)}")  # 오류 발생 시 메시지 추가
+
+        return results
+
+    def get_multimodal_response(self, prompt, multimodal_data):
+        """멀티모달 데이터(이미지+텍스트)를 처리하는 메서드"""
+        try:
+            # 멀티모달 메시지 구성
+            messages = [{"role": "system", "content": prompt}]
+            
+            # 사용자 메시지 구성
+            user_content = []
+            
+            for item in multimodal_data:
+                if item["type"] == "image":
+                    # 이미지 데이터를 base64로 전송
+                    user_content.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{item['data']}",
+                            "detail": "low"
+                        }
+                    })
+                elif item["type"] == "text":
+                    # 텍스트 데이터 추가
+                    if user_content and user_content[-1].get("type") == "text":
+                        # 이미 텍스트가 있으면 기존 텍스트에 추가
+                        user_content[-1]["text"] += f"\n{item['data']}"
+                    else:
+                        # 새로운 텍스트 블록 생성
+                        user_content.append({
+                            "type": "text",
+                            "text": item["data"]
+                        })
+            
+            # 사용자 메시지 추가
+            messages.append({
+                "role": "user",
+                "content": user_content
+            })
+            
+            # GPT-4o 모델로 멀티모달 요청
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                temperature=0,
+                max_tokens=1000
+            )
+            
+            return [response.choices[0].message.content.strip()]
+            
+        except Exception as e:
+            return [f"멀티모달 처리 오류: {str(e)}"]
+
+    

orangecontrib/orange3example/utils/microbit.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+import serial
+import time
+import serial.tools.list_ports
+import threading
+import sys
+import io
+
+# Windows에서 콘솔 출력 인코딩 문제 해결
+if sys.platform == 'win32':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except AttributeError:
+        # Python 3.6 이하 버전에서는 reconfigure가 없음
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+        sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+
+_connection = None
+_text_input_callback = None
+_is_listening = False
+
+
+def list_ports() -> list:
+    """사용 가능한 시리얼 포트 목록 반환"""
+    return [port.device for port in serial.tools.list_ports.comports()]
+
+
+def connect(port: str, baudrate: int = 115200, timeout: float = 1.0) -> str:
+    """포트에 연결 시도. 성공 시 포트명 반환."""
+    global _connection
+    if _connection:
+        _connection.close()
+    _connection = serial.Serial(port, baudrate=baudrate, timeout=timeout)
+    time.sleep(2)  # 연결 안정화 대기
+    return _connection.port
+
+
+def disconnect():
+    """연결 해제"""
+    global _connection, _is_listening
+    _is_listening = False
+    if _connection and _connection.is_open:
+        _connection.close()
+        _connection = None
+
+
+def is_connected() -> bool:
+    """현재 연결 여부 반환"""
+    global _connection
+    return _connection is not None and _connection.is_open
+
+
+def send_and_receive(message: str, wait_time: float = 2.0) -> str:
+    """메시지 전송 후 응답 수신"""
+    global _connection
+    if not _connection or not _connection.is_open:
+        raise RuntimeError("Microbit 연결이 되어 있지 않습니다. connect(port)를 먼저 호출하세요.")
+
+    _connection.reset_input_buffer()  # 🧹 이전 수신 버퍼 정리
+    # CRLF로 전송 (마이크로비트/펌웨어에서 CRLF를 기대하는 경우 대응)
+    _connection.write((message + '\r\n').encode('utf-8'))
+
+    time.sleep(wait_time)
+
+    if _connection.in_waiting > 0:
+        try:
+            response = _connection.readline().decode('utf-8', errors='ignore').strip()
+            return response if response else "[응답 없음]"
+        except Exception as e:
+            return f"[디코딩 오류: {str(e)}]"
+    else:
+        return "[타임아웃: 응답 없음]"
+
+
+def send_text(text: str) -> bool:
+    """텍스트를 마이크로비트로 즉시 전송"""
+    global _connection
+    if not _connection or not _connection.is_open:
+        print("Microbit 연결이 되어 있지 않습니다.")
+        return False
+    
+    try:
+        # 이전 수신 버퍼를 비우고, CRLF로 전송
+        _connection.reset_input_buffer()
+        message = text.strip() + '\r\n'
+        _connection.write(message.encode('utf-8'))
+        _connection.flush()  # 버퍼 즉시 전송
+        time.sleep(0.05)  # 전송 안정화 짧은 대기
+        print(f"전송됨: {text}")
+        return True
+    except Exception as e:
+        print(f"전송 오류: {str(e)}")
+        return False
+
+
+def start_text_listening(callback=None):
+    """마이크로비트로부터 텍스트 응답을 실시간으로 수신하는 리스너 시작"""
+    global _connection, _text_input_callback, _is_listening
+    
+    if not _connection or not _connection.is_open:
+        print("Microbit 연결이 되어 있지 않습니다.")
+        return False
+    
+    _text_input_callback = callback
+    _is_listening = True
+    
+    def listen_thread():
+        while _is_listening and _connection and _connection.is_open:
+            try:
+                if _connection.in_waiting > 0:
+                    # 완전한 응답을 받기 위해 타임아웃을 두고 모든 데이터 읽기
+                    response_parts = []
+                    no_data_count = 0
+                    max_no_data = 20  # 0.05초 * 20 = 1초 동안 추가 데이터 없으면 완료로 간주
+                    start_time = time.time()
+                    max_wait_time = 2.0  # 최대 2초 대기
+                    
+                    while True:
+                        current_time = time.time()
+                        if current_time - start_time > max_wait_time:
+                            break  # 최대 대기 시간 초과
+                        
+                        if _connection.in_waiting > 0:
+                            # 사용 가능한 모든 바이트 읽기
+                            available_bytes = _connection.in_waiting
+                            data = _connection.read(available_bytes).decode('utf-8', errors='ignore')
+                            if data:
+                                response_parts.append(data)
+                                no_data_count = 0  # 데이터가 있으면 카운터 리셋
+                                start_time = current_time  # 데이터가 오면 시간 리셋
+                        else:
+                            no_data_count += 1
+                            if no_data_count >= max_no_data:
+                                break  # 추가 데이터 없음, 응답 완료
+                        
+                        time.sleep(0.05)  # 짧은 대기
+                    
+                    if response_parts:
+                        # 모든 데이터를 합쳐서 하나의 응답으로 처리
+                        full_response = "".join(response_parts).strip()
+                        # 개행 문자 제거 및 정리
+                        full_response = full_response.replace('\r', '').replace('\n', ' ')
+                        # 여러 공백을 하나로 합치기
+                        full_response = ' '.join(full_response.split())
+                        if full_response and _text_input_callback:
+                            _text_input_callback(full_response)
+                time.sleep(0.1)  # CPU 사용량 줄이기
+            except Exception as e:
+                print(f"리스닝 오류: {str(e)}")
+                break
+    
+    # 별도 스레드에서 리스닝 시작
+    listener = threading.Thread(target=listen_thread, daemon=True)
+    listener.start()
+    print("마이크로비트 응답 리스닝 시작됨")
+    return True
+
+
+def stop_text_listening():
+    """텍스트 응답 리스닝 중지"""
+    global _is_listening
+    _is_listening = False
+    print("마이크로비트 응답 리스닝 중지됨")
+
+
+def send_text_with_response(text: str, wait_time: float = 1.0) -> str:
+    """텍스트 전송 후 응답 대기"""
+    if send_text(text):
+        time.sleep(wait_time)
+        if _connection and _connection.in_waiting > 0:
+            try:
+                response = _connection.readline().decode('utf-8', errors='ignore').strip()
+                return response if response else "[응답 없음]"
+            except Exception as e:
+                return f"[응답 읽기 오류: {str(e)}]"
+        else:
+            return "[응답 없음]"
+    return "[전송 실패]"

orangecontrib/orange3example/utils/webcam.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+import cv2
+
+cap = None
+
+def start_camera(index=0):
+    global cap
+    if cap is None:
+        cap = cv2.VideoCapture(index)
+
+
+def read_frame():
+    global cap
+    if cap is not None and cap.isOpened():
+        ret, frame = cap.read()
+        if ret:
+            return frame
+    return None
+
+def stop_camera():
+    global cap
+    if cap is not None:
+        cap.release()
+        cap = None

orangecontrib/orange3example/widgets/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from . import owllmtransformer
+from . import owmicrobit
+from . import owwebcam
+from . import owimagellm

orangecontrib/orange3example/widgets/owimagellm.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets import gui
+from Orange.widgets.settings import Setting
+import Orange.data
+from PyQt5.QtWidgets import QTextEdit, QLabel, QVBoxLayout, QHBoxLayout, QLineEdit
+from PyQt5.QtGui import QPixmap, QImage
+from PyQt5.QtCore import Qt
+import numpy as np
+import base64
+import io
+from PIL import Image
+from orangecontrib.orange3example.utils.llm import LLM
+
+class OWImageLLM(OWWidget):
+    name = "Image LLM"
+    description = "마이크로비트 이미지와 텍스트를 입력받아 멀티모달 LLM으로 처리하는 Orange3 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 20
+    api_key = Setting("")
+
+    class Inputs:
+        image_data = Input("이미지 데이터", np.ndarray, auto_summary=False)
+        text_data = Input("텍스트 데이터", Orange.data.Table)
+
+    class Outputs:
+        llm_response = Output("LLM 응답", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        # 이미지 표시 영역
+        self.image_label = QLabel("이미지가 입력되지 않았습니다")
+        self.image_label.setAlignment(Qt.AlignCenter)
+        self.image_label.setMinimumSize(200, 150)
+        self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+        
+        # API Key 입력 필드
+        self.api_key_input = QLineEdit(self.controlArea)
+        self.api_key_input.setPlaceholderText("OpenAI API Key")
+        self.api_key_input.setEchoMode(QLineEdit.Password)
+        self.api_key_input.setText(self.api_key)
+
+        # 프롬프트 입력 필드
+        self.prompt = "이 이미지와 텍스트를 분석해주세요."
+        self.prompt_input = QTextEdit(self.controlArea)
+        self.prompt_input.setPlainText(self.prompt)
+        self.prompt_input.setPlaceholderText("여기에 프롬프트를 입력하세요...")
+        self.prompt_input.setMinimumHeight(80)
+        
+        # 실행 버튼
+        self.process_button = gui.button(
+            self.controlArea, self, "멀티모달 분석 실행", callback=self.process
+        )
+        self.process_button.setDisabled(True)
+        
+        # 결과 출력 필드
+        self.result_display = QTextEdit()
+        self.result_display.setReadOnly(True)
+        self.result_display.setMinimumHeight(100)
+        
+        # 레이아웃 설정
+        control_layout = QVBoxLayout()
+        control_layout.addWidget(QLabel("입력 이미지:"))
+        control_layout.addWidget(self.image_label)
+        control_layout.addWidget(QLabel("API Key"))
+        control_layout.addWidget(self.api_key_input)
+        control_layout.addWidget(QLabel("프롬프트:"))
+        control_layout.addWidget(self.prompt_input)
+        control_layout.addWidget(self.process_button)
+        self.controlArea.layout().addLayout(control_layout)
+        
+        # 메인 영역에 결과 표시
+        self.mainArea.layout().addWidget(QLabel("LLM 응답 결과:"))
+        self.mainArea.layout().addWidget(self.result_display)
+        
+        # 데이터 저장 변수
+        self.image_data = None
+        self.text_data = None
+        self.has_image = False
+        self.has_text = False
+
+    @Inputs.image_data
+    def set_image_data(self, data):
+        """이미지 데이터 입력 처리"""
+        if data is not None and isinstance(data, np.ndarray):
+            self.image_data = data
+            self.has_image = True
+            self.display_image(data)
+            self.check_inputs()
+            # 이미지가 들어오면 자동으로 처리
+            if self.has_text:
+                self.process()
+        else:
+            self.image_data = None
+            self.has_image = False
+            self.image_label.setText("이미지가 입력되지 않았습니다")
+            self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+            self.check_inputs()
+
+    @Inputs.text_data
+    def set_text_data(self, data):
+        """텍스트 데이터 입력 처리"""
+        if data is not None and isinstance(data, Orange.data.Table):
+            self.text_data = data
+            self.has_text = True
+            self.check_inputs()
+            # 텍스트가 들어오면 자동으로 처리
+            if self.has_image:
+                self.process()
+        else:
+            self.text_data = None
+            self.has_text = False
+            self.check_inputs()
+
+    def display_image(self, image_array):
+        """numpy 배열을 QPixmap으로 변환하여 표시"""
+        try:
+            # 이미지가 RGB 형식으로 전달되었으므로 그대로 사용
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                # RGB 이미지를 PIL Image로 변환
+                pil_image = Image.fromarray(image_array.astype(np.uint8))
+            else:
+                # 그레이스케일 또는 다른 형식인 경우 RGB로 변환
+                pil_image = Image.fromarray(image_array.astype(np.uint8))
+                if len(pil_image.getbands()) == 1:
+                    pil_image = pil_image.convert('RGB')
+            
+            # QPixmap으로 변환
+            buffer = io.BytesIO()
+            pil_image.save(buffer, format='PNG')
+            qimage = QImage.fromData(buffer.getvalue())
+            pixmap = QPixmap.fromImage(qimage)
+            
+            # 이미지 크기 조정
+            pixmap = pixmap.scaled(200, 150, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+            self.image_label.setPixmap(pixmap)
+            self.image_label.setStyleSheet("border: none;")
+            
+        except Exception as e:
+            self.image_label.setText(f"이미지 표시 오류: {str(e)}")
+            self.image_label.setStyleSheet("border: 2px dashed #ccc;")
+
+    def check_inputs(self):
+        """입력 데이터 상태 확인 및 버튼 활성화/비활성화"""
+        if self.has_image or self.has_text:
+            self.process_button.setDisabled(False)
+        else:
+            self.process_button.setDisabled(True)
+
+    def process(self):
+        """멀티모달 LLM 처리 실행"""
+        try:
+            self.prompt = self.prompt_input.toPlainText()
+            api_key_value = (self.api_key_input.text() or "").strip() or None
+            # Setting 저장
+            self.api_key = self.api_key_input.text()
+            
+            # LLM 인스턴스 생성
+            llm = LLM(api_key=api_key_value)
+            
+            # 멀티모달 데이터 준비
+            multimodal_data = self.prepare_multimodal_data()
+            
+            # LLM API 호출
+            results = llm.get_multimodal_response(self.prompt, multimodal_data)
+            
+            # 결과를 Orange 데이터 테이블로 변환 (메타에 저장)
+            domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("LLM Response")])
+            response_data = Orange.data.Table.from_list(domain, [[str(result)] for result in results])
+            
+            # 출력 전송
+            self.Outputs.llm_response.send(response_data)
+            
+            # 결과 표시
+            self.result_display.setPlainText("\n".join(results))
+            
+        except Exception as e:
+            error_msg = f"처리 중 오류 발생: {str(e)}"
+            self.result_display.setPlainText(error_msg)
+            
+            # 오류 결과도 출력으로 전송
+            domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Error")])
+            error_data = Orange.data.Table.from_list(domain, [[error_msg]])
+            self.Outputs.llm_response.send(error_data)
+
+    def prepare_multimodal_data(self):
+        """멀티모달 데이터 준비"""
+        multimodal_content = []
+        
+        # 이미지 데이터가 있는 경우 base64로 인코딩
+        if self.has_image and self.image_data is not None:
+            try:
+                # 이미지를 base64로 인코딩
+                pil_image = Image.fromarray(self.image_data.astype(np.uint8))
+                buffer = io.BytesIO()
+                pil_image.save(buffer, format='PNG')
+                image_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                
+                multimodal_content.append({
+                    "type": "image",
+                    "data": image_base64,
+                    "description": "마이크로비트에서 전송된 이미지"
+                })
+            except Exception as e:
+                multimodal_content.append({
+                    "type": "text",
+                    "data": f"이미지 처리 오류: {str(e)}"
+                })
+        
+        # 텍스트 데이터가 있는 경우
+        if self.has_text and self.text_data is not None:
+            try:
+                # string-meta 변수들을 텍스트로 변환
+                string_meta_indices = [
+                    idx for idx, var in enumerate(self.text_data.domain.metas)
+                    if isinstance(var, Orange.data.StringVariable)
+                ]
+                
+                if string_meta_indices:
+                    text_content = [
+                        " ".join(str(row.metas[idx]) for idx in string_meta_indices)
+                        for row in self.text_data
+                    ]
+                    multimodal_content.append({
+                        "type": "text",
+                        "data": "\n".join(text_content)
+                    })
+                else:
+                    multimodal_content.append({
+                        "type": "text",
+                        "data": "텍스트 데이터 없음"
+                    })
+            except Exception as e:
+                multimodal_content.append({
+                    "type": "text",
+                    "data": f"텍스트 처리 오류: {str(e)}"
+                })
+        
+        return multimodal_content

orangecontrib/orange3example/widgets/owllmtransformer.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+from Orange.widgets.widget import OWWidget, Input, Output
+from Orange.widgets import gui
+from Orange.widgets.settings import Setting
+import Orange.data
+from PyQt5.QtWidgets import QTextEdit, QLineEdit, QLabel  # QTextEdit 사용
+from orangecontrib.orange3example.utils.llm import LLM  # llm.py에서 LLM 클래스를 가져옴
+
+class OWLLMTransformer(OWWidget):
+    name = "LLM Transformer"
+    description = "GPT API를 통해 입력 데이터를 변환하는 Orange3 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 10
+    api_key = Setting("")
+
+    class Inputs:
+        text_data = Input("입력 데이터", Orange.data.Table)
+
+    class Outputs:
+        transformed_data = Output("GPT 응답 데이터", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        # API Key 입력 필드
+        self.api_key_input = QLineEdit(self.controlArea)
+        self.api_key_input.setPlaceholderText("OpenAI API Key")
+        self.api_key_input.setEchoMode(QLineEdit.Password)
+        self.api_key_input.setText(self.api_key)
+        self.controlArea.layout().addWidget(QLabel("API Key"))
+        self.controlArea.layout().addWidget(self.api_key_input)
+
+        # 프롬프트 입력 필드를 크게 만들기 위해 QTextEdit 사용
+        self.prompt = "입력 데이터를 변환해주세요."
+        self.prompt_input = QTextEdit(self.controlArea)  # QTextEdit으로 프롬프트 입력창 확대
+        self.prompt_input.setPlainText(self.prompt)
+        self.prompt_input.setPlaceholderText("여기에 프롬프트를 입력하세요...")
+        self.prompt_input.setMinimumHeight(100)  # 높이 조정
+        self.controlArea.layout().addWidget(self.prompt_input)
+
+        # 변환 실행 버튼
+        self.transform_button = gui.button(
+            self.controlArea, self, "변환 실행", callback=self.process
+        )
+        self.transform_button.setDisabled(True)  # 초기에는 비활성화
+
+        # 🛠 결과 출력 필드 (QTextEdit 사용)
+        self.result_text = ""
+        self.result_display = QTextEdit()
+        self.result_display.setReadOnly(True)  # 읽기 전용 설정
+        self.mainArea.layout().addWidget(self.result_display)  # Orange3의 레이아웃에 추가
+
+        self.text_data = None
+
+    @Inputs.text_data
+    def set_data(self, data):
+        if isinstance(data, Orange.data.Table):
+            # 모든 string-meta 변수를 찾음
+            string_meta_indices = [
+                idx for idx, var in enumerate(data.domain.metas)
+                if isinstance(var, Orange.data.StringVariable)
+            ]
+            # 모든 string-meta 변수를 모아서 하나의 문자열로 합침
+            data = [
+                " ".join(str(row.metas[idx]) for idx in string_meta_indices)
+                for row in data
+            ]
+
+        self.text_data = data
+        self.transform_button.setDisabled(False)
+
+
+    def process(self):
+        """변환 실행 버튼을 눌렀을 때만 GPT API 호출"""
+        self.prompt = self.prompt_input.toPlainText()
+        api_key_value = (self.api_key_input.text() or "").strip() or None
+        # Setting 저장
+        self.api_key = self.api_key_input.text()
+        
+        # 문자열 데이터를 위한 메타 데이터 설정
+        domain = Orange.data.Domain([], metas=[Orange.data.StringVariable("Transformed Text")])
+
+        # GPT API 호출
+        llm = LLM(api_key=api_key_value)
+        results = llm.get_response(self.prompt, self.text_data) 
+        transformed_data = Orange.data.Table.from_list(domain, [[str(result)] for result in results])
+
+        # 변환된 결과를 출력으로 보냄
+        self.Outputs.transformed_data.send(transformed_data)
+
+        # 결과 출력 UI 업데이트
+        self.result_text = "\n".join(results)  # 결과를 하나의 텍스트로 연결
+        self.result_display.setPlainText(self.result_text)

orangecontrib/orange3example/widgets/owmicrobit.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+from Orange.widgets.widget import OWWidget, Input
+import Orange.data
+from Orange.data import StringVariable
+
+from PyQt5.QtWidgets import QTextEdit, QPushButton, QComboBox, QLabel, QHBoxLayout, QWidget, QVBoxLayout, QCheckBox
+from orangecontrib.orange3example.utils import microbit
+
+
+class OWMicrobit(OWWidget):
+    name = "Microbit Communicator"
+    description = "통신 포트를 통해 마이크로비트로 데이터를 전송하는 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 20
+
+    class Inputs:
+        text_data = Input("입력 텍스트", Orange.data.Table)
+
+    def __init__(self):
+        super().__init__()
+
+        self.text_data = None
+
+        # 포트 선택 UI
+        port_layout = QHBoxLayout()
+        port_widget = QWidget()
+        port_widget.setLayout(port_layout)
+
+        self.port_combo = QComboBox()
+        self.port_combo.setEditable(True)
+        port_layout.addWidget(self.port_combo)
+
+        self.refresh_button = QPushButton("🔄")
+        self.refresh_button.clicked.connect(self.refresh_ports)
+        port_layout.addWidget(self.refresh_button)
+
+        self.connect_button = QPushButton("연결")
+        self.connect_button.clicked.connect(self.connect_to_microbit)
+        port_layout.addWidget(self.connect_button)
+
+        self.status_label = QLabel("연결되지 않음")
+        port_layout.addWidget(self.status_label)
+
+        self.controlArea.layout().addWidget(port_widget)
+
+        # 전송 텍스트 입력
+        self.send_box = QTextEdit()
+        self.send_box.setPlaceholderText("마이크로비트로 보낼 텍스트를 입력하세요")
+        self.send_box.setMaximumHeight(80)
+        self.controlArea.layout().addWidget(self.send_box)
+
+        # 버튼 레이아웃
+        button_layout = QHBoxLayout()
+        
+        self.send_button = QPushButton("전송")
+        self.send_button.clicked.connect(self.send_to_microbit)
+        button_layout.addWidget(self.send_button)
+        
+        self.auto_send_checkbox = QCheckBox("자동 전송")
+        self.auto_send_checkbox.setChecked(True)
+        button_layout.addWidget(self.auto_send_checkbox)
+        
+        self.controlArea.layout().addLayout(button_layout)
+
+        # 로그 출력창
+        self.log_box = QTextEdit()
+        self.log_box.setReadOnly(True)
+        self.log_box.setMaximumHeight(100)
+        self.controlArea.layout().addWidget(self.log_box)
+
+        # 초기 포트 목록 로드
+        self.refresh_ports()
+
+    def log(self, text):
+        self.log_box.append(text)
+
+    def refresh_ports(self):
+        self.port_combo.clear()
+        self.log("🔄 포트 새로고침 중...")
+        if microbit:
+            try:
+                ports = microbit.list_ports()
+                if ports:
+                    self.port_combo.addItems(ports)
+                    self.log(f"사용 가능한 포트: {', '.join(ports)}")
+                else:
+                    self.log("사용 가능한 포트가 없습니다.")
+            except Exception as e:
+                self.log(f"포트 검색 실패: {str(e)}")
+        else:
+            self.log("microbit 모듈이 로드되지 않았습니다.")
+
+    def connect_to_microbit(self):
+        if not microbit:
+            self.status_label.setText("microbit 모듈 없음")
+            self.log("microbit 모듈이 없습니다.")
+            return
+
+        port = self.port_combo.currentText()
+        try:
+            microbit.connect(port)
+            self.status_label.setText(f"연결됨 ({port})")
+            self.log(f"{port} 포트에 연결되었습니다.")
+                
+        except Exception as e:
+            self.status_label.setText(f"연결 실패")
+            self.log(f"연결 실패: {str(e)}")
+
+    @Inputs.text_data
+    def set_text_data(self, data):
+        """[수정] 입력 텍스트 처리 로직 개선"""
+        if data is None:
+            self.log("입력 데이터가 None입니다.")
+            self.text_data = None
+            if not self.auto_send_checkbox.isChecked():
+                self.send_box.clear()
+            return
+            
+        if not isinstance(data, Orange.data.Table):
+            self.log(f"예상하지 못한 데이터 타입: {type(data)}")
+            return
+            
+        self.text_data = data
+        text = ""
+        
+        try:
+            # [수정] 모든 문자열 변수(속성, 클래스, 메타)에서 텍스트 추출
+            all_vars = data.domain.variables + data.domain.metas
+            string_vars = [var for var in all_vars if isinstance(var, StringVariable)]
+            
+            if string_vars:
+                text_content = []
+                for row in data:
+                    row_texts = []
+                    for var in string_vars:
+                        value = str(row[var]) 
+                        if value != "?" and value: # '?' 또는 빈 값 제외
+                            row_texts.append(value)
+                    if row_texts:
+                        text_content.append(" ".join(row_texts))
+                        
+                if text_content:
+                    text = "\n".join(text_content)
+                else:
+                    self.log("문자열 변수는 있으나 유효한 텍스트가 없습니다.")
+            else:
+                self.log("입력 테이블에 문자열(String) 변수가 없습니다.")
+
+            if text:
+                self.log(f"입력 데이터를 수신했습니다: {text}")
+                if self.auto_send_checkbox.isChecked():
+                    self.send_text_to_microbit(text)
+                else:
+                    self.send_box.setPlainText(text)
+            else:
+                self.log("입력에서 추출된 텍스트가 없습니다.")
+                if not self.auto_send_checkbox.isChecked():
+                    self.send_box.clear()
+                    
+        except Exception as e:
+            self.log(f"입력 텍스트 추출 실패: {e}")
+
+    def send_text_to_microbit(self, text: str):
+        """마이크로비트로 텍스트 전송 (단방향)"""
+        if not text:
+            self.log("전송할 텍스트가 없습니다.")
+            return
+
+        if not microbit:
+            self.log("microbit 모듈이 없습니다.")
+            return
+
+        if not microbit.is_connected():
+            self.log("포트가 연결되지 않았습니다.")
+            return
+
+        try:
+            # 비-블로킹 전송만 사용
+            if hasattr(microbit, 'send_text'):
+                success = microbit.send_text(text)
+                if success:
+                    self.log(f"전송됨: {text}")
+                else:
+                    self.log("전송 실패")
+            else:
+                self.log("오류: 'send_text' 함수가 microbit 모듈에 없습니다.")
+                
+        except Exception as e:
+            self.log(f"전송 중 오류 발생: {str(e)}")
+
+    def send_to_microbit(self):
+        text = self.send_box.toPlainText().strip()
+        self.send_text_to_microbit(text)

orangecontrib/orange3example/widgets/owwebcam.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+from Orange.widgets.widget import OWWidget
+from Orange.widgets import gui
+from PyQt5.QtWidgets import QLabel, QPushButton, QVBoxLayout
+from PyQt5.QtGui import QPixmap, QImage
+from PyQt5.QtCore import QTimer
+import numpy as np
+import cv2
+
+try:
+    from orangecontrib.orange3example.utils import webcam
+except ImportError:
+    webcam = None
+
+class OWWebcam(OWWidget):
+    name = "Webcam Viewer"
+    description = "웹캠을 실시간으로 표시하고 캡쳐 버튼을 눌러 이미지를 전송하는 위젯"
+    icon = "../icons/machine-learning-03-svgrepo-com.svg"
+    priority = 30
+
+    # Output signal 정의
+    outputs = [("Image", np.ndarray)]
+
+    def __init__(self):
+        super().__init__()
+
+        self.image_label = QLabel("웹캠이 시작되지 않았습니다.")
+        self.controlArea.layout().addWidget(self.image_label)
+
+        self.start_button = QPushButton("웹캠 시작")
+        self.stop_button = QPushButton("중지")
+        self.capture_button = QPushButton("이미지 캡쳐")
+        self.capture_button.setEnabled(False)
+
+        self.controlArea.layout().addWidget(self.start_button)
+        self.controlArea.layout().addWidget(self.stop_button)
+        self.controlArea.layout().addWidget(self.capture_button)
+
+        self.start_button.clicked.connect(self.start_webcam)
+        self.stop_button.clicked.connect(self.stop_webcam)
+        self.capture_button.clicked.connect(self.capture_image)
+
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.update_frame)
+        
+        # 웹캠 상태 추적
+        self.webcam_active = False
+        self.current_frame = None  # 현재 프레임 저장
+
+    def start_webcam(self):
+        if webcam:
+            webcam.start_camera()
+            self.timer.start(30)  # 약 30 FPS
+            self.webcam_active = True
+            self.capture_button.setEnabled(True)
+            self.start_button.setEnabled(False)
+
+    def stop_webcam(self):
+        self.timer.stop()
+        if webcam:
+            webcam.stop_camera()
+        self.webcam_active = False
+        self.capture_button.setEnabled(False)
+        self.start_button.setEnabled(True)
+        self.current_frame = None
+        self.image_label.setText("웹캠이 중지되었습니다.")
+        # 웹캠 중지 시 output 클리어
+        self.send("Image", None)
+
+    def update_frame(self):
+        """웹캠 프레임을 읽어서 화면에만 표시 (출력은 보내지 않음)"""
+        if not webcam or not self.webcam_active:
+            return
+        frame = webcam.read_frame()
+        if frame is None:
+            return
+        
+        # 현재 프레임을 저장 (캡쳐용)
+        self.current_frame = frame.copy()
+            
+        # 화면에 표시만 (BGR 형식 그대로 사용)
+        frame_qimage = cvt_frame_to_qimage(frame)
+        pixmap = QPixmap.fromImage(frame_qimage)
+        self.image_label.setPixmap(pixmap)
+        
+        # 출력은 보내지 않음 (캡쳐 버튼을 눌렀을 때만 보냄)
+
+    def capture_image(self):
+        """현재 프레임을 캡쳐해서 출력으로 전송"""
+        if self.current_frame is None:
+            return
+        
+        # BGR -> RGB 변환 후 출력으로 전송
+        frame_rgb = cv2.cvtColor(self.current_frame, cv2.COLOR_BGR2RGB)
+        self.send("Image", frame_rgb)
+
+
+def cvt_frame_to_qimage(frame):
+    h, w, ch = frame.shape
+    bytes_per_line = ch * w
+    # OpenCV는 BGR 형식이므로 BGR888 사용
+    image = QImage(frame.data, w, h, bytes_per_line, QImage.Format_BGR888)
+    return image