Upload folder using huggingface_hub

app.py

@@ -42,146 +42,37 @@ from datasets import load_dataset
 from typing import Tuple, Optional
 
 # ============ CONFIG ============
-DATASET_ID = "amkyawdev/amkyaw-core-ecosystem"
-
-# Load custom CSS
-css_custom = """
-/* Amkyaw Core Ecosystem - Advanced Glassmorphism UI */
-
-/* Dark theme base */
-:root {
-    --bg-dark: #0a0a0f;
-    --bg-dark-secondary: #12121a;
-    --glass-bg: rgba(255, 255, 255, 0.03);
-    --glass-bg-hover: rgba(255, 255, 255, 0.08);
-    --glass-border: rgba(255, 255, 255, 0.08);
-    --primary: #8b5cf6;
-    --primary-hover: #a78bfa;
-    --text-main: #f1f5f9;
-    --text-muted: #94a3b8;
-    --text-muted-hover: #cbd5e1;
-    --accent: #f472b6;
-    
-    /* Stage colors */
-    --negation-red: #ef4444;
-    --negation-bg: rgba(239, 68, 68, 0.1);
-    --structure-blue: #3b82f6;
-    --structure-bg: rgba(59, 130, 246, 0.1);
-    --optimized-green: #22c55e;
-    --optimized-bg: rgba(34, 197, 94, 0.1);
-    
-    /* Myanmar-friendly settings */
-    --line-height: 1.8;
-    --font-myanmar: 'Noto Sans Myanmar', 'Myanmar Text', 'Padauk', sans-serif;
-}
-
-body {
-    background: var(--bg-dark);
-    background-image: 
-        radial-gradient(ellipse at 20% 0%, rgba(139, 92, 246, 0.15) 0%, transparent 50%),
-        radial-gradient(ellipse at 80% 100%, rgba(244, 114, 182, 0.1) 0%, transparent 50%),
-        linear-gradient(180deg, var(--bg-dark) 0%, var(--bg-dark-secondary) 100%);
-    color: var(--text-main);
-    font-family: var(--font-myanmar);
-    line-height: var(--line-height);
-    min-height: 100vh;
-}
-
-/* Main container */
-.gradio-container {
-    background: var(--glass-bg) !important;
-    backdrop-filter: blur(20px);
-    border: 1px solid var(--glass-border);
-    border-radius: 20px;
-    box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
-}
-
-/* Input styling */
-.input-text, .gradio-input-text {
-    background: rgba(255, 255, 255, 0.05) !important;
-    border: 1px solid var(--glass-border) !important;
-    color: var(--text-main) !important;
-    border-radius: 12px !important;
-    padding: 12px 16px !important;
-    font-family: var(--font-myanmar) !important;
-}
-
-.input-text:focus, .gradio-input-text:focus {
-    border-color: var(--primary) !important;
-    box-shadow: 0 0 0 3px rgba(139, 92, 246, 0.2) !important;
-}
-
-.input-text::placeholder {
-    color: var(--text-muted) !important;
-}
-
-/* Button styling */
-button.primary, .gradio-button-primary {
-    background: #8b5cf6 !important;
-    border: none !important;
-    color: white !important;
-    font-weight: 600 !important;
-    border-radius: 12px !important;
-    transition: all 0.3s ease !important;
-    padding: 10px 20px !important;
-}
-
-button.primary:hover, .gradio-button-primary:hover {
-    background: #a78bfa !important;
-    transform: translateY(-2px);
-}
-
-/* Logic Cards - Glassmorphism */
-.logic-card {
-    background: rgba(255, 255, 255, 0.05) !important;
-    backdrop-filter: blur(10px);
-    border-radius: 16px;
-    padding: 20px;
-    margin: 12px 0;
-    border: 1px solid rgba(255, 255, 255, 0.1);
-}
-
-/* Negation Card - Red */
-.logic-card.negation {
-    border-left: 4px solid #ef4444;
-    background: rgba(239, 68, 68, 0.1) !important;
-}
-
-/* Structure Card - Blue */
-.logic-card.structural {
-    border-left: 4px solid #3b82f6;
-    background: rgba(59, 130, 246, 0.1) !important;
-}
-
-/* Optimized Card - Green */
-.logic-card.optimized {
-    border-left: 4px solid #22c55e;
-    background: rgba(34, 197, 94, 0.1) !important;
-}
-
-/* Main response */
-.main-response {
-    background: rgba(139, 92, 246, 0.15) !important;
-    backdrop-filter: blur(10px);
-    border-radius: 16px;
-    padding: 24px;
-    border: 1px solid rgba(139, 92, 246, 0.3);
-}
-
-/* Animations */
-@keyframes fadeIn {
-    from { opacity: 0; transform: translateY(10px); }
-    to { opacity: 1; transform: translateY(0); }
-}
-
-.logic-card { animation: fadeIn 0.4s ease-out; }
+import os
+import sys
 
-/* Scrollbar */
-::-webkit-scrollbar { width: 8px; }
-::-webkit-scrollbar-track { background: #0a0a0f; }
-::-webkit-scrollbar-thumb { background: rgba(255, 255, 255, 0.1); border-radius: 4px; }
-::-webkit-scrollbar-thumb:hover { background: #8b5cf6; }
-"""
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(__file__))
+
+# Load CSS from assets file
+def load_css():
+    # Path relative to app.py location
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    css_path = os.path.join(base_dir, "assets", "style.css")
+    if os.path.exists(css_path):
+        with open(css_path, "r") as f:
+            return f.read()
+    # Fallback: try relative to current directory
+    if os.path.exists("assets/style.css"):
+        with open("assets/style.css", "r") as f:
+            return f.read()
+    return ""
+
+# Import from core module
+try:
+    from core.logic_engine import AmkyawLogicEngine
+    from core.formatter import format_logic_output
+except ImportError:
+    # Fallback if module import fails
+    AmkyawLogicEngine = None
+    format_logic_output = None
+
+# Dataset ID
+DATASET_ID = "amkyawdev/amkyaw-core-ecosystem"
 
 # Cache for loaded dataset
 _dataset_cache = None
@@ -290,7 +181,7 @@ def format_stage_html(title: str, content: str, icon: str, stage_type: str = "ne
 def create_demo():
     """Create the Gradio demo interface"""
     
-    with gr.Blocks(css=css_custom, title="Amkyaw Core - Logic Visualizer") as demo:
+    with gr.Blocks(css=load_css(), title="Amkyaw Core - Logic Visualizer") as demo:
         gr.Markdown("""
         # 🧠 Amkyaw Core Ecosystem
         ## Logic Visualizer

core/__init__.py

@@ -1 +1,2 @@
-# Amkyaw Core Package
+# Amkyaw Core Package
+# Empty file to enable module imports

core/formatter.py

@@ -1,41 +1,93 @@
 """
-Formatter - Format JSONL data for UI display
+Formatter - Format JSONL data for UI display with Glassmorphism HTML
+
+Wraps step_1_negation, step_2_fifty_fifty, step_3_optimized into HTML cards
 """
 
 from typing import Dict, Any
 
 
-def format_logic_output(result: Dict[str, Any]) -> tuple:
+def format_stage_html(title: str, content: str, icon: str, stage_type: str) -> str:
+    """
+    Format a logic step as a Glassmorphism HTML card
+    
+    Args:
+        title: Card title (e.g., "Step 1: Negation")
+        content: The logic step content
+        icon: Emoji icon
+        stage_type: "negation", "structural", or "optimized"
+        
+    Returns:
+        HTML string for the card
+    """
+    html = f'''
+    <div class="logic-card {stage_type}">
+        <div class="card-header">
+            <span class="card-icon">{icon}</span>
+            <span class="card-title">{title}</span>
+        </div>
+        <div class="card-content">
+            {content}
+        </div>
+    </div>
+    '''
+    return html
+
+
+def format_logic_steps(logic_steps: Dict[str, str]) -> tuple:
     """
-    Format logic engine result for UI display
+    Format logic steps for UI display
     
     Args:
-        result: Result from AmkyawLogicEngine
+        logic_steps: Dict with step_1_negation, step_2_fifty_fifty, step_3_optimized
         
     Returns:
-        tuple of (formatted_output, thought_trace)
+        Tuple of (optimized_output, negation_html, structural_html, optimized_html)
     """
+    if not logic_steps:
+        return "", "", "", ""
+    
+    negation = logic_steps.get("step_1_negation", "")
+    structural = logic_steps.get("step_2_fifty_fifty", "")
+    optimized = logic_steps.get("step_3_optimized", "")
+    
+    # Format HTML cards
+    negation_html = format_stage_html(
+        "Step 1: Negation (ဆန့်ကျင်ဘက်)", 
+        negation, 
+        "🔥", 
+        "negation"
+    )
+    structural_html = format_stage_html(
+        "Step 2: Structure (မျှခြေ)", 
+        structural, 
+        "⚖️", 
+        "structural"
+    )
+    optimized_html = format_stage_html(
+        "Step 3: Optimized (အကောင်းဆုံး)", 
+        optimized, 
+        "✨", 
+        "optimized"
+    )
+    
+    return optimized, negation_html, structural_html, optimized_html
+
+
+def format_logic_output(result: Dict[str, Any]) -> tuple:
+    """Legacy function for backward compatibility"""
     if not result:
         return "No result", ""
     
-    # Get thought trace
     stages = result.get("stages", {})
     
-    trace_lines = [
-        "🧠 **Stage 1: Negation (ဆန့်ကျင်ဘက်)**",
-        stages.get("negation", "Not defined"),
-        "",
-        "⚖️ **Stage 2: Structure (မျှခြေ)**",
-        stages.get("structure", "Not defined"),
-        "",
-        "✨ **Stage 3: Synthesis (အကောင်းဆုံး)**",
-        stages.get("synthesis", "Not defined")
-    ]
-    
-    thought_trace = "\n".join(trace_lines)
-    output = result.get("output", stages.get("synthesis", ""))
+    logic_steps = {
+        "step_1_negation": stages.get("negation", ""),
+        "step_2_fifty_fifty": stages.get("structure", ""),
+        "step_3_optimized": stages.get("synthesis", "")
+    }
     
-    return output, thought_trace
+    return format_logic_steps(logic_steps)
 
 
 def format_sample_data(sample: Dict) -> str:

core/logic_engine.py

@@ -1,17 +1,91 @@
 """
 AmkyawLogic Engine - 3-Stage Reasoning Framework
+
+Loads dataset: amkyawdev/amkyaw-core-ecosystem
+Returns: step_1_negation, step_2_fifty_fifty, step_3_optimized
 """
 
-from typing import Dict, List, Any
+from typing import Dict, List, Any, Optional
+from datasets import load_dataset
 
+DATASET_ID = "amkyawdev/amkyaw-core-ecosystem"
+_dataset_cache = None
 
-class AmkyawLogicEngine:
+
+def get_dataset():
+    """Load and cache dataset"""
+    global _dataset_cache
+    if _dataset_cache is None:
+        try:
+            _dataset_cache = load_dataset(DATASET_ID, split="train")
+        except Exception as e:
+            print(f"Error loading dataset: {e}")
+            return None
+    return _dataset_cache
+
+
+def search_dataset(user_input: str, dataset) -> Optional[Dict]:
+    """
+    Search dataset for matching instruction
+    
+    Args:
+        user_input: User's search query
+        dataset: The amkyaw-core-ecosystem dataset
+        
+    Returns:
+        Dict with logic_steps or None if not found
     """
-    AmkyawLogic Engine implements the 3-stage reasoning:
-    1. Negation (Stage 1) - Define what something IS NOT
-    2. Structure/Equilibrium (Stage 2) - 50/50 balance
-    3. Optimized Synthesis (Stage 3) - Best answer
+    if dataset is None:
+        return None
+    
+    user_input_lower = user_input.lower().strip()
+    
+    # Search through dataset
+    for item in dataset:
+        instruction = item.get("instruction", "").lower()
+        input_field = item.get("input", "").lower()
+        
+        # Check if user input matches instruction (partial match)
+        if user_input_lower in instruction or instruction in user_input_lower:
+            return item
+        if input_field and (user_input_lower in input_field or input_field in user_input_lower):
+            return item
+    
+    return None
+
+
+def get_logic_steps(user_input: str) -> Dict[str, str]:
     """
+    Get 3-stage logic steps from dataset
+    
+    Args:
+        user_input: User's search query
+        
+    Returns:
+        Dict with keys: step_1_negation, step_2_fifty_fifty, step_3_optimized
+    """
+    dataset = get_dataset()
+    result = search_dataset(user_input, dataset)
+    
+    if result:
+        logic_steps = result.get("logic_steps", {})
+        return {
+            "step_1_negation": logic_steps.get("step_1_negation", "Not found"),
+            "step_2_fifty_fifty": logic_steps.get("step_2_fifty_fifty", "Not found"),
+            "step_3_optimized": logic_steps.get("step_3_optimized", result.get("label", "Not found"))
+        }
+    
+    # Mock response if no match
+    return {
+        "step_1_negation": f"'{user_input}' ဆိုတဲ့ အရာသည် အခြားသော အရာမဟုတ်ပါ။",
+        "step_2_fifty_fifty": f"'{user_input}' သည် မျှခြေဖြစ်ပပါ။",
+        "step_3_optimized": f"'{user_input}' အတွက် အကောင်းဆုံး အဖြေသည် မြန်မာ့ယဉ်ကျေးမှု၊ ခေတ်သစ် အလှအပပါယ်ဖြစ်ပပါ။"
+    }
+
+
+# Backward compatibility class
+class AmkyawLogicEngine:
+    """AmkyawLogic Engine implements the 3-stage reasoning"""
     
     def __init__(self):
         self.stage_names = [
@@ -21,74 +95,43 @@ class AmkyawLogicEngine:
         ]
     
     def process(self, instruction: str, dataset) -> Dict[str, Any]:
-        """
-        Process an instruction through the 3-stage logic
-        
-        Args:
-            instruction: The user's instruction/query
-            dataset: The amkyaw-core-ecosystem dataset
-            
-        Returns:
-            Dict with reasoning stages and output
-        """
+        """Process an instruction through the 3-stage logic"""
         result = {
             "instruction": instruction,
             "stages": {},
             "output": ""
         }
         
-        # Stage 1: Negation - What is NOT the answer
         result["stages"]["negation"] = self._stage_negation(instruction, dataset)
-        
-        # Stage 2: Structure - 50/50 equilibrium  
         result["stages"]["structure"] = self._stage_structure(instruction, dataset)
-        
-        # Stage 3: Optimized Synthesis
         result["stages"]["synthesis"] = self._stage_optimized(instruction, dataset)
-        
-        # Final output
         result["output"] = result["stages"]["synthesis"]
         
         return result
     
     def _stage_negation(self, instruction: str, dataset) -> str:
         """Stage 1: Negation - Define boundaries"""
-        # Search for matching instruction in dataset
-        for item in dataset:
-            if item.get("instruction", "").lower() in instruction.lower():
-                logic_steps = item.get("logic_steps", {})
-                return logic_steps.get("step_1_negation", "Not found in dataset")
-        return "Boundary not defined"
+        logic = get_logic_steps(instruction)
+        return logic.get("step_1_negation", "Boundary not defined")
     
     def _stage_structure(self, instruction: str, dataset) -> str:
         """Stage 2: Structure - 50/50 balance"""
-        for item in dataset:
-            if item.get("instruction", "").lower() in instruction.lower():
-                logic_steps = item.get("logic_steps", {})
-                return logic_steps.get("step_2_fifty_fifty", "Structure not found")
-        return "Structure not defined"
+        logic = get_logic_steps(instruction)
+        return logic.get("step_2_fifty_fifty", "Structure not defined")
     
     def _stage_optimized(self, instruction: str, dataset) -> str:
         """Stage 3: Optimized Synthesis"""
-        for item in dataset:
-            if item.get("instruction", "").lower() in instruction.lower():
-                logic_steps = item.get("logic_steps", {})
-                return logic_steps.get("step_3_optimized", item.get("label", ""))
-        return "Analysis complete"
+        logic = get_logic_steps(instruction)
+        return logic.get("step_3_optimized", "Analysis complete")
     
     def get_thought_trace(self, result: Dict) -> str:
         """Generate thought trace from result"""
-        trace = []
-        
         stages = result.get("stages", {})
         
-        trace.append("🧠 Stage 1 (Negation):")
-        trace.append(stages.get("negation", ""))
-        
-        trace.append("\n⚖️ Stage 2 (Structure):")
-        trace.append(stages.get("structure", ""))
-        
-        trace.append("\n✨ Stage 3 (Synthesis):")
-        trace.append(stages.get("synthesis", ""))
+        trace = [
+            "🧠 Stage 1 (Negation): " + stages.get("negation", ""),
+            "⚖️ Stage 2 (Structure): " + stages.get("structure", ""),
+            "✨ Stage 3 (Synthesis): " + stages.get("synthesis", "")
+        ]
         
         return "\n".join(trace)