Upload 11 files

.env

@@ -0,0 +1,7 @@
+# Copy this to .env and fill in your actual values
+
+# OpenAI API Configuration
+OPENAI_API_KEY=sk-rHhP2-gXcfLHTJ8X6bL4pQ
+OPENAI_MODEL=gpt-oss-120b
+OPENAI_TEMPERATURE=0.7
+OPENAI_MAX_TOKENS=80000

Dockerfile

@@ -0,0 +1,33 @@
+# Use Python 3.11 slim image
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first (for better caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p generated_test_cases
+RUN mkdir -p uploads
+RUN mkdir -p inputFiles
+RUN mkdir -p "Example Output Files"
+RUN mkdir -p "Test Case Files"
+
+# Set permissions
+RUN chmod -R 755 /app
+
+# Expose port
+EXPOSE 7860
+
+# Hugging Face Spaces expects the app to run on port 7860
+ENV PORT=7860
+
+# Run the application
+CMD ["uvicorn", "apis:app", "--host", "0.0.0.0", "--port", "7860"]

apis.py

@@ -0,0 +1,164 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.responses import PlainTextResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from datetime import datetime
+from fastapi.responses import JSONResponse, RedirectResponse
+import os
+import tempfile
+import shutil
+import os,shutil,tempfile
+from main import PCBTestCaseApp
+from openai_client import TestCaseGenerator, HTMLGenerator
+
+app = FastAPI(title="PCB Test Case Generator API")
+
+
+# Add CORS middleware to allow frontend requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Create static directory if it doesn't exist
+os.makedirs("static", exist_ok=True)
+os.makedirs("html_outputs", exist_ok=True)
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+app.mount("/html-output", StaticFiles(directory="html_outputs"), name="html_outputs")
+
+@app.get("/")
+async def read_root():
+    """Redirect to static index.html"""
+    return RedirectResponse(url="/static/index.html")
+
+
+
+
+@app.post("/generate-test-case")
+async def generate_test_case(
+    manual_file: UploadFile = File(...),
+    ipc_file: UploadFile = File(...)
+):
+    """
+    Generate PCB test cases from uploaded files and return JSON with content for web rendering
+    
+    Args:
+        manual_file: Manual document file (required)
+        ipc_file: IPC file (required)
+        
+    Returns:
+        JSON response with test case content and metadata including HTML file path
+    """
+    temp_files = []
+    
+    try:
+        # Create temporary directory for uploaded files
+        temp_dir = tempfile.mkdtemp()
+        
+        # Save uploaded files temporarily
+        manual_path = os.path.join(temp_dir, manual_file.filename)
+        ipc_path = os.path.join(temp_dir, ipc_file.filename)
+        
+        with open(manual_path, "wb") as buffer:
+            content = await manual_file.read()
+            buffer.write(content)
+        temp_files.append(manual_path)
+        
+        with open(ipc_path, "wb") as buffer:
+            content = await ipc_file.read()
+            buffer.write(content)
+        temp_files.append(ipc_path)
+        
+        # Initialize PCB Test Case App
+        pcb_app = PCBTestCaseApp()
+        
+        # Fixed file paths (you can make these configurable)
+        sample_path = "Example Output Files/AE304196-001_LoRa Car Radio Bring-Up Procedure.docx"
+        d356_path = "Test Case Files/UNO-TH_Rev3e.d356"
+        bom_path = "Example Output Files/newModelBom.csv"
+        
+        # Ensure output directory exists
+        output_dir = "generated_test_cases"
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Get model name from config (from env file)
+        model_name = pcb_app.config.openai_model.replace("/", "_")
+
+        # Generate filename with current datetime and model name
+        timestamp = datetime.now().strftime("%d%m%y%H%M")
+        output_filename = f"{timestamp}_{model_name}.txt"
+        output_path = os.path.join(output_dir, output_filename)
+
+        # Generate test cases
+        test_cases = pcb_app.generate_test_cases(
+            manual_path, 
+            sample_path, 
+            ipc_path, 
+            d356_path, 
+            bom_path, 
+            output_path
+        )
+        
+        # Generate HTML output
+        output_dir_html = "html_outputs"
+        os.makedirs(output_dir_html, exist_ok=True)
+        print(f"=== GENERATING HTML OUTPUT ===")
+        
+        generator = HTMLGenerator(pcb_app.config)
+        html_output_path = os.path.join(output_dir_html, f"{timestamp}_{model_name}.html")
+        generator.text_file_to_html(output_path, html_output_path)
+
+        # Read the generated test case content
+        try:
+            with open(output_path, 'r', encoding='utf-8') as f:
+                test_case_content = f.read()
+        except UnicodeDecodeError:
+            # Try with different encodings if utf-8 fails
+            try:
+                with open(output_path, 'r', encoding='latin-1') as f:
+                    test_case_content = f.read()
+            except:
+                with open(output_path, 'r', encoding='cp1252') as f:
+                    test_case_content = f.read()
+        
+        # HTML file details
+        html_file_name = f"{timestamp}_{model_name}.html"
+        html_file_url = f"/html-output/{html_file_name}"
+        
+        # Return JSON response with content and metadata
+        return JSONResponse(
+            content={
+                "success": True,
+                "content": test_case_content,
+                "filename": output_filename,
+                "timestamp": timestamp,
+                "model": model_name,
+                "html_file": html_file_name,
+                "html_url": html_file_url
+            }
+        )
+    
+    except Exception as e:
+        print(f"Application error: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating test case: {str(e)}")
+    
+    finally:
+        # Clean up temporary files
+        for temp_file in temp_files:
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+        # Remove temporary directory
+        if 'temp_dir' in locals() and os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
+
+
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

config.py

@@ -0,0 +1,85 @@
+"""
+Configuration management for PCB Test Case Generator
+Handles API keys and application settings
+"""
+import os
+from typing import Optional
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+
+load_dotenv()  # Load environment variables from .env file if present
+
+@dataclass
+class Config:
+    """Configuration class for storing application settings"""
+    openai_api_key: Optional[str] = None
+    openai_base_url: Optional[str] = "https://api.ai.it.ufl.edu"
+    openai_model: str = "gpt-oss-120b"
+    temperature: float = 0.7
+    max_tokens: Optional[int] = None
+    
+    def __post_init__(self):
+        """Load configuration from environment variables"""
+        self.openai_api_key = os.getenv("OPENAI_API_KEY",self.openai_api_key)
+        print(self.openai_api_key)
+        # Optional proxy/base URL for OpenAI-compatible endpoints (e.g., LiteLLM proxy)
+        self.openai_base_url = os.getenv("OPENAI_BASE_URL", self.openai_base_url)
+        self.openai_model = os.getenv("OPENAI_MODEL", self.openai_model)
+        
+        # Load temperature from env if set
+        temp_env = os.getenv("OPENAI_TEMPERATURE",self.temperature)
+        if temp_env:
+            try:
+                self.temperature = float(temp_env)
+            except ValueError:
+                print(f"Warning: Invalid temperature value '{temp_env}', using default {self.temperature}")
+        
+        # Load max_tokens from env if set
+        tokens_env = os.getenv("OPENAI_MAX_TOKENS",self.max_tokens)
+        if tokens_env:
+            try:
+                self.max_tokens = int(tokens_env)
+            except ValueError:
+                print(f"Warning: Invalid max_tokens value '{tokens_env}', using default None")
+    
+    def validate(self) -> bool:
+        """Validate that required configuration is present"""
+        if not self.openai_api_key:
+            print("ERROR: OpenAI API key not found. Please set OPENAI_API_KEY environment variable.")
+            return False
+        return True
+    
+    @classmethod
+    def load_from_file(cls, config_file: str) -> 'Config':
+        """Load configuration from a file (optional implementation)"""
+        # This could be extended to load from JSON/YAML files
+        config = cls()
+        
+        # Example of loading from a simple text file
+        if os.path.exists(config_file):
+            try:
+                with open(config_file, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if '=' in line and not line.startswith('#'):
+                            key, value = line.split('=', 1)
+                            key, value = key.strip(), value.strip()
+                            
+                            if key == 'OPENAI_API_KEY':
+                                config.openai_api_key = value
+                            elif key == 'OPENAI_MODEL':
+                                config.openai_model = value
+                            elif key == 'OPENAI_TEMPERATURE':
+                                config.temperature = float(value)
+                            elif key == 'OPENAI_MAX_TOKENS':
+                                config.max_tokens = int(value)
+            except Exception as e:
+                print(f"Warning: Error loading config file {config_file}: {e}")
+        
+        return config
+
+
+# Global config instance
+app_config = Config()

main.py

@@ -0,0 +1,175 @@
+"""
+Main application file integrating document extraction and OpenAI API
+"""
+import sys
+from config import Config, app_config
+from openai_client import TestCaseGenerator, HTMLGenerator
+from realtime_feedback import RealTimeTestCaseGenerator
+from text_extractor import extract_text_from_docx, extract_text_from_csv, summarize_ipc_or_d356_data
+import os
+from datetime import datetime
+
+
+class PCBTestCaseApp:
+    """Main application class for PCB test case generation"""
+    
+    def __init__(self, config_file: str = None):
+        """Initialize the application"""
+        if config_file:
+            self.config = Config.load_from_file(config_file)
+        else:
+            self.config = app_config
+        
+        if not self.config.validate():
+            raise ValueError("Configuration validation failed")
+        
+        self.test_generator = TestCaseGenerator(self.config)
+        print(f"PCB Test Case Generator initialized with model: {self.config.openai_model}")
+    
+    def extract_documents(self, manual_path, sample_path, ipc_path, d356_path, bom_path):
+        """Extract content from all required documents"""
+        print("Extracting text from files...")
+        
+        # Extract manual text
+        try:
+            manual_text = extract_text_from_docx(manual_path)
+            print(f"Extracted {len(manual_text)} characters from manual.")
+        except Exception as e:
+            manual_text = "ERROR: Could not read PCB Manual. Ensure file exists and is a valid .docx."
+            print(f"{manual_text} {e}")
+
+        # Extract sample output text
+        try:
+            sample_output_text = extract_text_from_docx(sample_path)
+            print(f"Extracted {len(sample_output_text)} characters from sample output.")
+        except Exception as e:
+            sample_output_text = "ERROR: Could not read Sample Output. Ensure file exists and is a valid .docx."
+            print(f"{sample_output_text} {e}")
+
+        # Generate summaries
+        ipc_summary = summarize_ipc_or_d356_data(ipc_path, 'ipc')
+        print(f"Generated IPC summary: {len(ipc_summary)} characters.")
+
+        d356_summary = summarize_ipc_or_d356_data(d356_path, 'd356')
+        print(f"Generated D356 summary: {len(d356_summary)} characters.")
+
+        # Extract BOM text
+        try:
+            bom_text = extract_text_from_csv(bom_path)
+            print(f"Extracted {len(bom_text)} characters from BOM.")
+        except Exception as e:
+            bom_text = "ERROR: Could not read BOM. Ensure file exists and is a valid .csv."
+            print(f"{bom_text} {e}")
+        
+        return manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+    
+    def generate_test_cases(self, manual_path, sample_path, ipc_path, d356_path, bom_path, 
+                          output_path=None, preview_only=False):
+        """Generate PCB test cases from input documents"""
+        try:
+            # Extract documents
+            manual_text, sample_output_text, ipc_summary, d356_summary, bom_text = \
+                self.extract_documents(manual_path, sample_path, ipc_path, d356_path, bom_path)
+            
+            # Generate or preview
+            if preview_only:
+                print("\n=== PREVIEW MODE ===")
+                result = self.test_generator.generate(
+                    manual_text, sample_output_text, ipc_summary, d356_summary, bom_text,
+                    preview_only=True
+                )
+                print(result)
+                return result
+            else:
+                print("\n=== GENERATING TEST CASES ===")
+                result = self.test_generator.generate(
+                    manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+                )
+                
+                if output_path:
+                    with open(output_path, 'w', encoding='utf-8') as f:
+                        f.write(result)
+                    print(f"Test cases saved to: {output_path}")
+                
+                return result
+                
+        except Exception as e:
+            print(f"Error generating test cases: {e}")
+            raise
+
+
+def main():
+    """Main entry point"""
+    try:
+        app = PCBTestCaseApp()
+        
+        # File paths from your existing code
+        manual_path = "inputFiles/Clemson_HW_Spec_V4_092325.docx"
+        sample_path = "Example Output Files/AE304196-001_LoRa Car Radio Bring-Up Procedure.docx"
+        ipc_path = "inputFiles/Assembly Testpoint Report for Car-PCB1.ipc"
+        d356_path = "Test Case Files/UNO-TH_Rev3e.d356"
+        bom_path = "Example Output Files/newModelBom.csv"
+        # Ensure output directory exists
+        output_dir = "generated_test_cases"
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Get model name from config (from env file)
+        model_name = app.config.openai_model.replace("/", "_")
+
+        # Generate filename with current datetime and model name
+        timestamp = datetime.now().strftime("%d%m%y%H%M")
+        output_filename = f"{timestamp}_{model_name}.txt"
+        output_path = os.path.join(output_dir, output_filename)
+
+
+        preview_mode = "--preview" in sys.argv
+        stream_mode = "--stream" in sys.argv
+
+        if preview_mode:
+            app.generate_test_cases(manual_path, sample_path, ipc_path, d356_path, bom_path, preview_only=True)
+        elif stream_mode:
+            # Use the realtime streamer: extract documents first, then stream generation
+            manual_text, sample_output_text, ipc_summary, d356_summary, bom_text = \
+                app.extract_documents(manual_path, sample_path, ipc_path, d356_path, bom_path)
+
+            streamer = RealTimeTestCaseGenerator(app.config)
+
+            # Open the output file for incremental writes
+            with open(output_path, 'w', encoding='utf-8') as out_f:
+                def on_chunk(chunk: str):
+                    # Print to stdout and write to the file as chunks arrive
+                    try:
+                        print(chunk, end='')
+                    except Exception:
+                        pass
+                    try:
+                        out_f.write(chunk)
+                        out_f.flush()
+                    except Exception:
+                        pass
+
+                full_text = streamer.stream_generate(
+                    manual_text, sample_output_text, ipc_summary, d356_summary, bom_text,
+                    on_chunk=on_chunk
+                )
+
+            print(f"\nStreaming complete — full output saved to: {output_path}")
+        else:
+            test_cases = app.generate_test_cases(manual_path, sample_path, ipc_path, d356_path, bom_path, output_path)
+            print(f"\n=== GENERATED TEST CASES PREVIEW ===")
+            print(test_cases[:500] + "..." if len(test_cases) > 500 else test_cases)
+    
+    except Exception as e:
+        print(f"Application error: {e}")
+        sys.exit(1)
+    
+    output_dir_html = "html_outputs"
+    os.makedirs(output_dir_html, exist_ok=True)
+    print(f"=== GENERATING HTML OUTPUT ===")
+    generator  = HTMLGenerator(app.config)
+    html_output_path = os.path.join(output_dir_html, f"{timestamp}_{model_name}.html")
+    generator.text_file_to_html(output_path, html_output_path)
+    
+
+if __name__ == "__main__":
+    main()

openai_client.py

@@ -0,0 +1,298 @@
+from typing import List, Dict, Optional, Any
+from pathlib import Path
+import openai
+from config import Config
+
+
+class OpenAIClient:
+    """OpenAI API client with error handling and retry logic"""
+    
+    def __init__(self, config: Config):
+        """
+        Initialize OpenAI client with configuration
+        
+        Args:
+            config: Configuration object containing API settings
+        """
+        self.config = config
+        self.client = None
+        self._initialize_client()
+    
+    def _initialize_client(self) -> None:
+        """Initialize the OpenAI client"""
+        if not self.config.validate():
+            raise ValueError("Invalid configuration: missing API key")
+        
+        try:
+            # Use the new-style OpenAI client constructor which accepts api_key and base_url
+            client_kwargs = {"api_key": self.config.openai_api_key}
+            if getattr(self.config, "openai_base_url", None):
+                client_kwargs["base_url"] = self.config.openai_base_url
+
+            self.client = openai.OpenAI(**client_kwargs)
+            print(f"OpenAI client initialized with model: {self.config.openai_model}")
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize OpenAI client: {e}")
+    
+    def generate_test_cases(self, 
+                          manual_text: str, 
+                          sample_output_text: str, 
+                          ipc_summary: str, 
+                          d356_summary: str, 
+                          bom_text: str) -> str:
+        """
+        Generate PCB test cases using OpenAI API
+        
+        Args:
+            manual_text: PCB testing manual content
+            sample_output_text: Sample test report format
+            ipc_summary: IPC design summary
+            d356_summary: D356 test data summary
+            bom_text: Bill of materials text
+            
+        Returns:
+            Generated test cases as string
+            
+        Raises:
+            RuntimeError: If API call fails
+        """
+        try:
+            messages = self._prepare_messages(
+                manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+            )
+            
+            response = self._make_api_call(messages)
+            return self._extract_response_content(response)
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to generate test cases: {e}")
+    
+    def _prepare_messages(self, 
+                         manual_text: str, 
+                         sample_output_text: str, 
+                         ipc_summary: str, 
+                         d356_summary: str, 
+                         bom_text: str) -> List[Dict[str, str]]:
+        """Prepare messages for OpenAI API call"""
+        
+        system_message = {
+            "role": "system",
+            "content": (
+                "You are an expert PCB test engineer. Your task is to generate a comprehensive set of test cases "
+                "for a new PCB design. You must follow the testing methodologies and safety guidelines provided "
+                "in the 'PCB Manual' and structure the output strictly according to the 'Sample Test Report Format'. "
+                "The test cases should cover visual inspection, electrical tests, and functional tests relevant "
+                "to the components and design described. Think step-by-step to cover all critical aspects."
+            )
+        }
+        
+        user_message_content = f"""
+### PCB Manual for Reference:
+{manual_text}
+
+### Sample Test Report Format (Guidance for Structure and Content):
+{sample_output_text}
+
+### New Device Design Data (IPC Summary):
+This section provides a high-level overview of the new PCB's design.
+{ipc_summary}
+
+### New Device Test Data (D356 Summary):
+This section provides details about specific test points and electrical properties of the new PCB.
+{d356_summary}
+
+### New Device Bill of Materials (BOM):
+This is the list of components on the new PCB.
+{bom_text}
+
+---
+Based on the 'PCB Manual', the 'Sample Test Report Format', and the details of the 'New Device' (from IPC summary, D356 summary, and BOM), please generate a detailed list of test cases.
+
+Ensure the test cases are presented in the exact format demonstrated in the 'Sample Test Report Format', including headings, table structure, and level of detail. Focus on:
+
+1. **Visual Inspection:** Component orientation, solder quality, silkscreen errors.
+2. **Electrical Continuity & Shorts:** Critical power and ground nets, key signal lines.
+3. **Power System Tests:** Voltage rails, current draw.
+4. **Functional Tests:** Based on the components (e.g., if U1 is an MCU, test its I/O, if J1 is USB, test USB connectivity).
+5. **Environmental/Stress Tests:** If specified in the manual (e.g., temperature cycling - provide placeholders if data is not available).
+
+For each test case, provide a unique ID, a clear description, expected results, and leave space for 'Actual Result' and 'Pass/Fail'.
+"""
+        
+        user_message = {
+            "role": "user",
+            "content": user_message_content
+        }
+        
+        return [system_message, user_message]
+    
+    def _make_api_call(self, messages: List[Dict[str, str]]) -> Any:
+        """Make the actual API call to OpenAI"""
+        
+        # Prepare API call parameters
+        api_params = {
+            "model": self.config.openai_model,
+            "messages": messages,
+            "temperature": self.config.temperature
+        }
+        
+        # Add max_tokens if specified
+        if self.config.max_tokens:
+            api_params["max_tokens"] = self.config.max_tokens
+        
+        try:
+            # Using the new client instance to create a chat completion via the proxy-compatible API
+            response = self.client.chat.completions.create(**api_params)
+            return response
+        except Exception as e:
+            # Generic catch — the new OpenAI SDK raises different exception types depending on the transport
+            raise RuntimeError(f"OpenAI API call failed: {e}")
+    
+    def _extract_response_content(self, response: Any) -> str:
+        """Extract content from OpenAI API response"""
+        try:
+            return response.choices[0].message.content
+        except (AttributeError, IndexError, KeyError) as e:
+            raise RuntimeError(f"Failed to extract response content: {e}")
+    
+    def get_prompt_info(self, 
+                       manual_text: str, 
+                       sample_output_text: str, 
+                       ipc_summary: str, 
+                       d356_summary: str, 
+                       bom_text: str) -> Dict[str, Any]:
+        """
+        Get information about the prompt without making an API call
+        
+        Returns:
+            Dictionary with prompt information including token estimates
+        """
+        messages = self._prepare_messages(
+            manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+        )
+        
+        system_content = messages[0]["content"]
+        user_content = messages[1]["content"]
+        
+        # Rough token estimation (1 token ≈ 4 characters for English text)
+        total_chars = len(system_content) + len(user_content)
+        estimated_tokens = total_chars // 4
+        
+        return {
+            "system_message": system_content,
+            "user_message_preview": user_content[:500] + "..." if len(user_content) > 500 else user_content,
+            "total_characters": total_chars,
+            "estimated_tokens": estimated_tokens,
+            "model": self.config.openai_model,
+            "temperature": self.config.temperature
+        }
+
+
+class TestCaseGenerator:
+    """High-level interface for generating PCB test cases"""
+    
+    def __init__(self, config: Config):
+        """Initialize with configuration"""
+        self.config = config
+        self.openai_client = OpenAIClient(config)
+    
+    def generate(self, 
+                manual_text: str, 
+                sample_output_text: str, 
+                ipc_summary: str, 
+                d356_summary: str, 
+                bom_text: str,
+                preview_only: bool = False) -> str:
+        """
+        Generate test cases or preview prompt
+        
+        Args:
+            manual_text: PCB testing manual content
+            sample_output_text: Sample test report format
+            ipc_summary: IPC design summary
+            d356_summary: D356 test data summary
+            bom_text: Bill of materials text
+            preview_only: If True, return prompt info instead of generating
+            
+        Returns:
+            Generated test cases or prompt information
+        """
+        if preview_only:
+            prompt_info = self.openai_client.get_prompt_info(
+                manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+            )
+            
+            return f"""
+--- Generated Prompt Structure (for review) ---
+System Message:
+{prompt_info['system_message']}
+
+User Message (preview):
+{prompt_info['user_message_preview']}
+
+Total characters: {prompt_info['total_characters']}
+Estimated tokens: {prompt_info['estimated_tokens']}
+Model: {prompt_info['model']}
+Temperature: {prompt_info['temperature']}
+"""
+        else:
+            return self.openai_client.generate_test_cases(
+                manual_text, sample_output_text, ipc_summary, d356_summary, bom_text
+            )
+        
+class HTMLGenerator:
+    """Class to convert a text file to HTML using OpenAI API and save the result."""
+    def __init__(self, config: Config):
+        self.config = config
+        self.openai_client = OpenAIClient(config)
+
+    def text_file_to_html(self, input_txt_path: str, output_html_path: str):
+        """
+        Convert a text file to HTML using OpenAI API and save the result.
+        Args:
+            input_txt_path: Path to the input text file.
+            output_html_path: Path to save the output HTML file.
+        Returns:
+            The generated HTML content as a string.
+        Raises:
+            RuntimeError: If API call or file operations fail.
+        """
+        try:
+            with open(input_txt_path, 'r', encoding='utf-8') as f:
+                text_content = f.read()
+        except Exception as e:
+            raise RuntimeError(f"Failed to read input file: {e}")
+
+        # Prepare prompt for HTML conversion
+        messages = [
+            {
+                "role": "system",
+                "content": """You are a expert HTML and CSS webpage designer.  
+                                Convert the following plain text into a clean, well‑structured
+                                HTML page with styled CSS. Add colours and fonts to enhance readability.  
+                                Keep headings, paragraphs, lists, and add basic styling so
+                                the page looks presentable in a browser.
+                                DO NOT  OUTPUT ANYTHING ELSE OTHER THAN WHAT IS STATED, OTHER WISE YOU WILL BE PENALIZED"""
+            },
+            {
+                "role": "user",
+                "content": f"Convert the following text to HTML and style.\n\n{text_content}"
+            }
+        ]
+
+        try:
+            response = self.openai_client._make_api_call(messages)
+            html_content = self.openai_client._extract_response_content(response)
+        except Exception as e:
+            raise RuntimeError(f"OpenAI API call failed: {e}")
+
+        try:
+            with open(output_html_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+        except Exception as e:
+            raise RuntimeError(f"Failed to write HTML file: {e}")
+
+"""
+OpenAI API client for PCB test case generation
+Handles all OpenAI API interactions with proper error handling
+"""

realtime_feedback.py

@@ -0,0 +1,145 @@
+"""
+Realtime feedback / streaming helper for test-case generation.
+
+This module provides a separate class to perform streamed chat completions
+and deliver incremental chunks to a caller-provided callback. It is kept
+separate from `openai_client.py` so existing code paths remain unchanged.
+
+Usage (non-blocking design):
+    from config import Config
+    from realtime_feedback import RealTimeTestCaseGenerator
+
+    cfg = Config(openai_api_key='sk-xxx', openai_base_url='https://api.ai.it.ufl.edu')
+    streamer = RealTimeTestCaseGenerator(cfg)
+
+    def on_chunk(chunk: str):
+        print(chunk, end='')
+
+    full_text = streamer.stream_generate(manual_text, sample_text, ipc_summary, d356_summary, bom_text, on_chunk=on_chunk)
+    print('\n--- done ---')
+
+The implementation tries to be robust to different SDK streaming event shapes
+and will call the `on_chunk` callback for each incoming text delta. It also
+returns the full assembled text once streaming completes.
+"""
+from typing import Callable, Optional, Any, List, Dict
+from openai_client import OpenAIClient
+from config import Config
+
+
+class RealTimeTestCaseGenerator:
+    """Provides a streaming interface for test-case generation."""
+
+    def __init__(self, config: Config):
+        """Create a streamer using the same Config as other components.
+
+        The class internally uses `OpenAIClient` to obtain a configured
+        `openai.OpenAI` client instance, so auth/proxy settings remain
+        consistent with the rest of the application.
+        """
+        self.config = config
+        self.openai_client = OpenAIClient(config)
+
+    def _build_api_params(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {
+            "model": self.config.openai_model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "stream": True,
+        }
+        if self.config.max_tokens:
+            params["max_tokens"] = self.config.max_tokens
+        return params
+
+    def stream_generate(self,
+                        manual_text: str,
+                        sample_output_text: str,
+                        ipc_summary: str,
+                        d356_summary: str,
+                        bom_text: str,
+                        on_chunk: Optional[Callable[[str], None]] = None) -> str:
+        """Stream generation from the model and call `on_chunk` for each delta.
+
+        Returns the assembled full text once streaming completes.
+        """
+        # Reuse the same prompt construction as OpenAIClient
+        # Build the messages payload here (kept minimal — mirror _prepare_messages)
+        system_message = {
+            "role": "system",
+            "content": (
+                "You are an expert PCB test engineer. Your task is to generate a comprehensive set of test cases "
+                "for a new PCB design. Follow instructions and produce step-by-step test cases."
+            )
+        }
+
+        user_message_content = f"""
+### PCB Manual for Reference:
+{manual_text}
+
+### Sample Test Report Format (Guidance for Structure and Content):
+{sample_output_text}
+
+### New Device Design Data (IPC Summary):
+{ipc_summary}
+
+### New Device Test Data (D356 Summary):
+{d356_summary}
+
+### New Device Bill of Materials (BOM):
+{bom_text}
+
+Please stream the generated test cases in the same format as the sample.
+"""
+
+        user_message = {"role": "user", "content": user_message_content}
+        messages = [system_message, user_message]
+
+        api_params = self._build_api_params(messages)
+
+        full_text = ""
+
+        # Create the streaming iterator from the configured client
+        try:
+            stream_iterable = self.openai_client.client.chat.completions.create(**api_params)
+        except Exception as e:
+            raise RuntimeError(f"Failed to start streaming API call: {e}")
+
+        # Iterate over streaming events. Different transports/SDK versions
+        # may yield slightly different shapes; be defensive when extracting text.
+        for event in stream_iterable:
+            chunk = None
+            # Try dict-like access first
+            try:
+                # event could be a mapping
+                choice = event.get("choices", [None])[0] if isinstance(event, dict) else None
+                if choice:
+                    delta = choice.get("delta") or choice.get("message") or {}
+                    if isinstance(delta, dict):
+                        chunk = delta.get("content") or delta.get("text")
+            except Exception:
+                chunk = None
+
+            # Try attribute-style access
+            if not chunk:
+                try:
+                    choice = getattr(event, "choices", None)
+                    if choice:
+                        c0 = choice[0]
+                        delta = getattr(c0, "delta", None) or getattr(c0, "message", None)
+                        if hasattr(delta, "get"):
+                            chunk = delta.get("content") or delta.get("text")
+                        else:
+                            chunk = getattr(delta, "content", None)
+                except Exception:
+                    chunk = None
+
+            if chunk:
+                full_text += chunk
+                if on_chunk:
+                    try:
+                        on_chunk(chunk)
+                    except Exception:
+                        # Don't let callback errors stop streaming
+                        pass
+
+        return full_text

requirements.txt

@@ -0,0 +1,24 @@
+annotated-types==0.7.0
+anyio==4.11.0
+certifi==2025.8.3
+colorama==0.4.6
+distro==1.9.0
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.10
+jiter==0.11.0
+lxml==6.0.2
+openai==1.109.1
+pillow==11.3.0
+pydantic==2.11.9
+pydantic_core==2.33.2
+python-docx==1.2.0
+sniffio==1.3.1
+tqdm==4.67.1
+typing-inspection==0.4.1
+typing_extensions==4.15.0
+fastapi
+uvicorn[standard]
+python-multipart
+dotenv

test_openai_init.py

@@ -0,0 +1,16 @@
+import openai
+
+print('openai module file =', getattr(openai, '__file__', 'builtin'))
+
+# Create a client using the new constructor style. Use a dummy API key (do not print it).
+client = openai.OpenAI( base_url='https://api.ai.it.ufl.edu')
+print('client created:', type(client))
+
+# Sanity-check attributes exist (don't call network)
+has_chat = hasattr(client, 'chat')
+print('client has chat attribute:', has_chat)
+try:
+    has_completions = hasattr(client.chat, 'completions')
+    print('client.chat has completions attribute:', has_completions)
+except Exception as e:
+    print('Could not introspect client.chat:', e)

test_realtime_feedback.py

@@ -0,0 +1,8 @@
+from config import Config
+from realtime_feedback import RealTimeTestCaseGenerator
+
+cfg = Config(openai_api_key='test-key', openai_base_url='https://api.ai.it.ufl.edu')
+print('Config OK', cfg.openai_api_key, cfg.openai_base_url)
+
+streamer = RealTimeTestCaseGenerator(cfg)
+print('Streamer created:', streamer)

text_extractor.py

@@ -0,0 +1,85 @@
+import docx
+import csv
+import io # Used for handling string as file-like object for IPC/D356 summaries
+
+def extract_text_from_docx(filepath):
+    """Extracts all text from a .docx file."""
+    doc = docx.Document(filepath)
+    full_text = []
+    for para in doc.paragraphs:
+        full_text.append(para.text)
+    return "\n".join(full_text)
+
+def extract_text_from_csv(filepath):
+    """Extracts and formats text from a CSV file."""
+    with open(filepath, 'r', encoding='utf-8') as f:
+        reader = csv.reader(f)
+        header = next(reader) # Read header
+        csv_data = [", ".join(header)] # Start with header
+        for row in reader:
+            csv_data.append(", ".join(row))
+    return "\n".join(csv_data)
+
+def summarize_ipc_or_d356_data(filepath, file_type):
+    """
+    Placeholder for summarizing IPC or D356 data.
+    In a real application, this would involve a dedicated parser.
+    For demonstration, we'll return a placeholder string.
+    """
+    if file_type == 'ipc':
+        # Imagine complex parsing here, identifying ICs, connectors, critical nets etc.
+        # For now, it's a conceptual summary.
+        return f"Summary of {filepath} (IPC design data):\n" \
+               "- Identifies major components like U1 (MCU), U2 (Power IC), J1 (USB connector).\n" \
+               "- Provides connectivity information for power rails (VCC, GND) and data lines (e.g., I2C on U1 pins 3,4).\n" \
+               "- Indicates board dimensions and layer stackup.\n" \
+               "- Critical components: U1 (Microcontroller), U2 (Voltage Regulator), Q1 (MOSFET)."
+    elif file_type == 'd356':
+        # Imagine parsing test points, nets to check, etc.
+        return f"Summary of {filepath} (D356 test data):\n" \
+               "- Lists test points: TP1 (VCC_3V3), TP2 (GND), TP3 (U1_I2C_SDA).\n" \
+               "- Indicates net connectivity for electrical tests.\n" \
+               "- Specifies areas for visual inspection related to component placement."
+    else:
+        return f"Could not summarize unknown file type: {filepath}"
+
+
+# --- File Paths (Update these to your actual file paths) ---
+manual_path = "inputFiles/Clemson_HW_Spec_V4_092325.docx"
+sample_output_path = "Example Output Files/AE304196-001_LoRa Car Radio Bring-Up Procedure.docx"
+ipc_design_path = "inputFiles/Assembly Testpoint Report for Car-PCB1.ipc" # This is conceptual for direct LLM input
+
+# Test Data (for the new device you want to generate test cases for)
+new_device_d356_path = "Test Case Files/UNO-TH_Rev3e.d356" # This is conceptual for direct LLM input
+new_device_bom_path = "Example Output Files/newModelBom.csv"
+
+# --- 1. Extract Text from Existing Files ---
+print("Extracting text from files...")
+try:
+    manual_text = extract_text_from_docx(manual_path)
+    print(f"Extracted {len(manual_text)} characters from manual.")
+except Exception as e:
+    manual_text = "ERROR: Could not read PCB Manual. Ensure file exists and is a valid .docx."
+    print(manual_text, e)
+
+try:
+    sample_output_text = extract_text_from_docx(sample_output_path)
+    print(f"Extracted {len(sample_output_text)} characters from sample output.")
+except Exception as e:
+    sample_output_text = "ERROR: Could not read Sample Output. Ensure file exists and is a valid .docx."
+    print(sample_output_text, e)
+
+# Summarize IPC and D356 (conceptual for LLM input)
+# In a real scenario, you'd run external tools or parsers here.
+ipc_summary = summarize_ipc_or_d356_data(ipc_design_path, 'ipc')
+print(f"Generated IPC summary (conceptual): {len(ipc_summary)} characters.")
+
+d356_summary = summarize_ipc_or_d356_data(new_device_d356_path, 'd356')
+print(f"Generated D356 summary (conceptual): {len(d356_summary)} characters.")
+
+try:
+    new_device_bom_text = extract_text_from_csv(new_device_bom_path)
+    print(f"Extracted {len(new_device_bom_text)} characters from new device BOM.")
+except Exception as e:
+    new_device_bom_text = "ERROR: Could not read New Device BOM. Ensure file exists and is a valid .csv."
+    print(new_device_bom_text, e)