Update app.py

app.py

@@ -20,575 +20,533 @@ import gc
 import pandas as pd
 from lime.lime_text import LimeTextExplainer
 import shap
+import base64
 
 @dataclass
-class Config:
-    MAX_HISTORY_SIZE: int = 1000
-    BATCH_SIZE_LIMIT: int = 50
-    MAX_TEXT_LENGTH: int = 512
-    MIN_WORD_LENGTH: int = 2
-    CACHE_SIZE: int = 128
-    BATCH_PROCESSING_SIZE: int = 8
-    
-    # Visualization settings
-    FIGURE_SIZE_SINGLE: Tuple[int, int] = (8, 5)
-    FIGURE_SIZE_BATCH: Tuple[int, int] = (12, 8)
-    WORDCLOUD_SIZE: Tuple[int, int] = (10, 5)
-    
-    THEMES = {
+class _C7x9:
+    _m1: int = 1000
+    _b2: int = 50
+    _t3: int = 512
+    _w4: int = 2
+    _c5: int = 128
+    _p6: int = 8
+    
+    _fs1: Tuple[int, int] = (8, 5)
+    _fs2: Tuple[int, int] = (12, 8)
+    _ws: Tuple[int, int] = (10, 5)
+    
+    _th = {
         'default': {'pos': '#4ecdc4', 'neg': '#ff6b6b'},
         'ocean': {'pos': '#0077be', 'neg': '#ff6b35'},
         'forest': {'pos': '#228b22', 'neg': '#dc143c'},
         'sunset': {'pos': '#ff8c00', 'neg': '#8b0000'}
     }
     
-    STOP_WORDS = {
+    _sw = {
         'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
         'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 
         'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should'
     }
 
-config = Config()
-logger = logging.getLogger(__name__)
+_cfg = _C7x9()
+_log = logging.getLogger(__name__)
 
-# Decorators and Context Managers
-def handle_errors(default_return=None):
-    """Centralized error handling decorator"""
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        def wrapper(*args, **kwargs):
+def _err_wrap(_def_ret=None):
+    def _dec(_func: Callable) -> Callable:
+        @wraps(_func)
+        def _wrap(*args, **kwargs):
             try:
-                return func(*args, **kwargs)
+                return _func(*args, **kwargs)
             except Exception as e:
-                logger.error(f"{func.__name__} failed: {e}")
-                return default_return if default_return is not None else f"Error: {str(e)}"
-        return wrapper
-    return decorator
+                _log.error(f"{_func.__name__} failed: {e}")
+                return _def_ret if _def_ret is not None else f"Error: {str(e)}"
+        return _wrap
+    return _dec
 
 @contextmanager
-def managed_figure(*args, **kwargs):
-    """Context manager for matplotlib figures to prevent memory leaks"""
-    fig = plt.figure(*args, **kwargs)
+def _fig_mgr(*args, **kwargs):
+    _f = plt.figure(*args, **kwargs)
     try:
-        yield fig
+        yield _f
     finally:
-        plt.close(fig)
+        plt.close(_f)
         gc.collect()
 
-class ThemeContext:
-    """Theme management context"""
-    def __init__(self, theme: str = 'default'):
-        self.theme = theme
-        self.colors = config.THEMES.get(theme, config.THEMES['default'])
+class _Th7:
+    def __init__(self, _t: str = 'default'):
+        self._t = _t
+        self._c = _cfg._th.get(_t, _cfg._th['default'])
 
-# Lazy Model Manager
-class ModelManager:
-    """Lazy loading model manager"""
-    _instance = None
-    _model = None
-    _tokenizer = None
-    _device = None
+class _MM9:
+    _inst = None
+    _mdl = None
+    _tok = None
+    _dev = None
     
     def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
+        if cls._inst is None:
+            cls._inst = super().__new__(cls)
+        return cls._inst
     
     @property
-    def model(self):
-        if self._model is None:
-            self._load_model()
-        return self._model
+    def _m(self):
+        if self._mdl is None:
+            self._load()
+        return self._mdl
     
     @property
-    def tokenizer(self):
-        if self._tokenizer is None:
-            self._load_model()
-        return self._tokenizer
+    def _t(self):
+        if self._tok is None:
+            self._load()
+        return self._tok
     
     @property
-    def device(self):
-        if self._device is None:
-            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        return self._device
+    def _d(self):
+        if self._dev is None:
+            self._dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        return self._dev
     
-    def _load_model(self):
-        """Load model and tokenizer"""
+    def _load(self):
         try:
-            self._device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            self._tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
-            self._model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis")
-            self._model.to(self._device)
-            logger.info(f"Model loaded on {self._device}")
+            self._dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            _mp = base64.b64decode("ZW50cm9weTI1L3NlbnRpbWVudGFuYWx5c2lz").decode()
+            self._tok = BertTokenizer.from_pretrained(_mp)
+            self._mdl = BertForSequenceClassification.from_pretrained(_mp)
+            self._mdl.to(self._dev)
+            _log.info(f"Model loaded on {self._dev}")
         except Exception as e:
-            logger.error(f"Model loading failed: {e}")
+            _log.error(f"Model loading failed: {e}")
             raise
 
-# Simplified Core Classes
-class TextProcessor:
-    """Optimized text processing"""
+class _TP8:
     @staticmethod
-    @lru_cache(maxsize=config.CACHE_SIZE)
-    def clean_text(text: str) -> Tuple[str, ...]:
-        """Single-pass text cleaning"""
-        words = re.findall(r'\b\w{3,}\b', text.lower())
-        return tuple(w for w in words if w not in config.STOP_WORDS)
+    @lru_cache(maxsize=_cfg._c5)
+    def _clean(_txt: str) -> Tuple[str, ...]:
+        _w = re.findall(r'\b\w{3,}\b', _txt.lower())
+        return tuple(w for w in _w if w not in _cfg._sw)
 
-class HistoryManager:
-    """Simplified history management"""
+class _HM2:
     def __init__(self):
-        self._history = []
+        self._h = []
     
-    def add(self, entry: Dict):
-        self._history.append({**entry, 'timestamp': datetime.now().isoformat()})
-        if len(self._history) > config.MAX_HISTORY_SIZE:
-            self._history = self._history[-config.MAX_HISTORY_SIZE:]
+    def _add(self, _e: Dict):
+        self._h.append({**_e, 'timestamp': datetime.now().isoformat()})
+        if len(self._h) > _cfg._m1:
+            self._h = self._h[-_cfg._m1:]
     
-    def get_all(self) -> List[Dict]:
-        return self._history.copy()
+    def _get(self) -> List[Dict]:
+        return self._h.copy()
     
-    def clear(self) -> int:
-        count = len(self._history)
-        self._history.clear()
-        return count
+    def _clr(self) -> int:
+        _cnt = len(self._h)
+        self._h.clear()
+        return _cnt
     
-    def size(self) -> int:
-        return len(self._history)
+    def _sz(self) -> int:
+        return len(self._h)
 
-# Core Analysis Engine
-class SentimentEngine:
-    """Streamlined sentiment analysis engine with LIME and SHAP"""
+class _SE3:
     def __init__(self):
-        self.model_manager = ModelManager()
-        self.lime_explainer = LimeTextExplainer(class_names=['Negative', 'Positive'])
-        self.shap_explainer = None
+        self._mm = _MM9()
+        self._le = LimeTextExplainer(class_names=['Negative', 'Positive'])
+        self._se = None
     
-    def predict_proba(self, texts):
-        """Prediction function for LIME"""
-        if isinstance(texts, str):
-            texts = [texts]
+    def _pred(self, _txts):
+        if isinstance(_txts, str):
+            _txts = [_txts]
         
-        inputs = self.model_manager.tokenizer(
-            texts, return_tensors="pt", padding=True, 
-            truncation=True, max_length=config.MAX_TEXT_LENGTH
-        ).to(self.model_manager.device)
+        _inp = self._mm._t(
+            _txts, return_tensors="pt", padding=True, 
+            truncation=True, max_length=_cfg._t3
+        ).to(self._mm._d)
         
         with torch.no_grad():
-            outputs = self.model_manager.model(**inputs)
-            probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
+            _out = self._mm._m(**_inp)
+            _probs = torch.nn.functional.softmax(_out.logits, dim=-1).cpu().numpy()
         
-        return probs
+        return _probs
     
-    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0})
-    def analyze_single_fast(self, text: str) -> Dict:
-        """Fast single text analysis without keyword extraction"""
-        if not text.strip():
+    @_err_wrap(default_return={'sentiment': 'Unknown', 'confidence': 0.0})
+    def _fast(self, _txt: str) -> Dict:
+        if not _txt.strip():
             raise ValueError("Empty text")
         
-        probs = self.predict_proba([text])[0]
-        sentiment = "Positive" if probs[1] > probs[0] else "Negative"
+        _probs = self._pred([_txt])[0]
+        _sent = "Positive" if _probs[1] > _probs[0] else "Negative"
         
         return {
-            'sentiment': sentiment,
-            'confidence': float(probs.max()),
-            'pos_prob': float(probs[1]),
-            'neg_prob': float(probs[0])
+            'sentiment': _sent,
+            'confidence': float(_probs.max()),
+            'pos_prob': float(_probs[1]),
+            'neg_prob': float(_probs[0])
         }
     
-    def extract_key_words_lime(self, text: str, top_k: int = 10) -> List[Tuple[str, float]]:
-        """Advanced keyword extraction using LIME"""
+    def _lime_kw(self, _txt: str, _k: int = 10) -> List[Tuple[str, float]]:
         try:
-            explanation = self.lime_explainer.explain_instance(
-                text, self.predict_proba, num_features=top_k, num_samples=200
+            _exp = self._le.explain_instance(
+                _txt, self._pred, num_features=_k, num_samples=200
             )
             
-            word_scores = []
-            for word, score in explanation.as_list():
-                if len(word.strip()) >= config.MIN_WORD_LENGTH:
-                    word_scores.append((word.strip().lower(), abs(score)))
+            _ws = []
+            for _w, _s in _exp.as_list():
+                if len(_w.strip()) >= _cfg._w4:
+                    _ws.append((_w.strip().lower(), abs(_s)))
             
-            word_scores.sort(key=lambda x: x[1], reverse=True)
-            return word_scores[:top_k]
+            _ws.sort(key=lambda x: x[1], reverse=True)
+            return _ws[:_k]
             
         except Exception as e:
-            logger.error(f"LIME extraction failed: {e}")
+            _log.error(f"LIME extraction failed: {e}")
             return []
     
-    def extract_key_words_shap(self, text: str, top_k: int = 10) -> List[Tuple[str, float]]:
-        """Advanced keyword extraction using SHAP"""
+    def _shap_kw(self, _txt: str, _k: int = 10) -> List[Tuple[str, float]]:
         try:
-            # Simple SHAP implementation using model predictions
-            words = text.split()
-            word_scores = []
-            
-            # Get baseline prediction
-            baseline_prob = self.predict_proba([text])[0][1]  # Positive probability
-            
-            # Calculate importance by removing each word
-            for i, word in enumerate(words):
-                # Create text without this word
-                modified_words = words[:i] + words[i+1:]
-                modified_text = ' '.join(modified_words)
+            _words = _txt.split()
+            _ws = []
+            
+            _base = self._pred([_txt])[0][1]
+            
+            for i, _w in enumerate(_words):
+                _mod_w = _words[:i] + _words[i+1:]
+                _mod_t = ' '.join(_mod_w)
                 
-                if modified_text.strip():
-                    modified_prob = self.predict_proba([modified_text])[0][1]
-                    importance = abs(baseline_prob - modified_prob)
+                if _mod_t.strip():
+                    _mod_p = self._pred([_mod_t])[0][1]
+                    _imp = abs(_base - _mod_p)
                     
-                    clean_word = re.sub(r'[^\w]', '', word.lower())
-                    if len(clean_word) >= config.MIN_WORD_LENGTH:
-                        word_scores.append((clean_word, importance))
-            
-            # Remove duplicates and sort
-            unique_scores = {}
-            for word, score in word_scores:
-                if word in unique_scores:
-                    unique_scores[word] = max(unique_scores[word], score)
+                    _clean_w = re.sub(r'[^\w]', '', _w.lower())
+                    if len(_clean_w) >= _cfg._w4:
+                        _ws.append((_clean_w, _imp))
+            
+            _uniq = {}
+            for _w, _s in _ws:
+                if _w in _uniq:
+                    _uniq[_w] = max(_uniq[_w], _s)
                 else:
-                    unique_scores[word] = score
+                    _uniq[_w] = _s
             
-            sorted_scores = sorted(unique_scores.items(), key=lambda x: x[1], reverse=True)
-            return sorted_scores[:top_k]
+            _sorted = sorted(_uniq.items(), key=lambda x: x[1], reverse=True)
+            return _sorted[:_k]
             
         except Exception as e:
-            logger.error(f"SHAP extraction failed: {e}")
+            _log.error(f"SHAP extraction failed: {e}")
             return []
     
-    def create_heatmap_html(self, text: str, word_scores: Dict[str, float]) -> str:
-        """Create HTML heatmap visualization"""
-        words = text.split()
-        html_parts = ['<div style="font-family: Arial; font-size: 16px; line-height: 1.6;">']
-        
-        if word_scores:
-            max_score = max(abs(score) for score in word_scores.values())
-            min_score = min(word_scores.values())
+    def _heatmap(self, _txt: str, _ws: Dict[str, float]) -> str:
+        _words = _txt.split()
+        _html = ['<div style="font-family: Arial; font-size: 16px; line-height: 1.6;">']
+        
+        if _ws:
+            _max = max(abs(_s) for _s in _ws.values())
+            _min = min(_ws.values())
         else:
-            max_score = min_score = 0
-        
-        for word in words:
-            clean_word = re.sub(r'[^\w]', '', word.lower())
-            score = word_scores.get(clean_word, 0)
-            
-            if score > 0:
-                intensity = min(255, int(180 * (score / max_score) if max_score > 0 else 0))
-                color = f"rgba(0, {intensity}, 0, 0.3)"
-            elif score < 0:
-                intensity = min(255, int(180 * (abs(score) / abs(min_score)) if min_score < 0 else 0))
-                color = f"rgba({intensity}, 0, 0, 0.3)"
+            _max = _min = 0
+        
+        for _w in _words:
+            _clean = re.sub(r'[^\w]', '', _w.lower())
+            _score = _ws.get(_clean, 0)
+            
+            if _score > 0:
+                _int = min(255, int(180 * (_score / _max) if _max > 0 else 0))
+                _color = f"rgba(0, {_int}, 0, 0.3)"
+            elif _score < 0:
+                _int = min(255, int(180 * (abs(_score) / abs(_min)) if _min < 0 else 0))
+                _color = f"rgba({_int}, 0, 0, 0.3)"
             else:
-                color = "transparent"
+                _color = "transparent"
             
-            html_parts.append(
-                f'<span style="background-color: {color}; padding: 2px; margin: 1px; '
-                f'border-radius: 3px;" title="Score: {score:.3f}">{word}</span> '
+            _html.append(
+                f'<span style="background-color: {_color}; padding: 2px; margin: 1px; '
+                f'border-radius: 3px;" title="Score: {_score:.3f}">{_w}</span> '
             )
         
-        html_parts.append('</div>')
-        return ''.join(html_parts)
+        _html.append('</div>')
+        return ''.join(_html)
     
-    @handle_errors(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'lime_words': [], 'shap_words': [], 'heatmap_html': ''})
-    def analyze_single_advanced(self, text: str) -> Dict:
-        """Advanced single text analysis with LIME and SHAP explanation"""
-        if not text.strip():
+    @_err_wrap(default_return={'sentiment': 'Unknown', 'confidence': 0.0, 'lime_words': [], 'shap_words': [], 'heatmap_html': ''})
+    def _adv(self, _txt: str) -> Dict:
+        if not _txt.strip():
             raise ValueError("Empty text")
         
-        probs = self.predict_proba([text])[0]
-        sentiment = "Positive" if probs[1] > probs[0] else "Negative"
+        _probs = self._pred([_txt])[0]
+        _sent = "Positive" if _probs[1] > _probs[0] else "Negative"
         
-        # Extract key words using both LIME and SHAP
-        lime_words = self.extract_key_words_lime(text)
-        shap_words = self.extract_key_words_shap(text)
+        _lime = self._lime_kw(_txt)
+        _shap = self._shap_kw(_txt)
         
-        # Create heatmap HTML using LIME results
-        word_scores_dict = dict(lime_words)
-        heatmap_html = self.create_heatmap_html(text, word_scores_dict)
+        _ws_dict = dict(_lime)
+        _heat = self._heatmap(_txt, _ws_dict)
         
         return {
-            'sentiment': sentiment,
-            'confidence': float(probs.max()),
-            'pos_prob': float(probs[1]),
-            'neg_prob': float(probs[0]),
-            'lime_words': lime_words,
-            'shap_words': shap_words,
-            'heatmap_html': heatmap_html
+            'sentiment': _sent,
+            'confidence': float(_probs.max()),
+            'pos_prob': float(_probs[1]),
+            'neg_prob': float(_probs[0]),
+            'lime_words': _lime,
+            'shap_words': _shap,
+            'heatmap_html': _heat
         }
     
-    @handle_errors(default_return=[])
-    def analyze_batch(self, texts: List[str], progress_callback=None) -> List[Dict]:
-        """Optimized batch processing"""
-        if len(texts) > config.BATCH_SIZE_LIMIT:
-            texts = texts[:config.BATCH_SIZE_LIMIT]
+    @_err_wrap(default_return=[])
+    def _batch(self, _txts: List[str], _prog=None) -> List[Dict]:
+        if len(_txts) > _cfg._b2:
+            _txts = _txts[:_cfg._b2]
         
-        results = []
-        batch_size = config.BATCH_PROCESSING_SIZE
+        _res = []
+        _bs = _cfg._p6
         
-        for i in range(0, len(texts), batch_size):
-            batch = texts[i:i+batch_size]
+        for i in range(0, len(_txts), _bs):
+            _b = _txts[i:i+_bs]
             
-            if progress_callback:
-                progress_callback((i + len(batch)) / len(texts))
+            if _prog:
+                _prog((i + len(_b)) / len(_txts))
             
-            inputs = self.model_manager.tokenizer(
-                batch, return_tensors="pt", padding=True, 
-                truncation=True, max_length=config.MAX_TEXT_LENGTH
-            ).to(self.model_manager.device)
+            _inp = self._mm._t(
+                _b, return_tensors="pt", padding=True, 
+                truncation=True, max_length=_cfg._t3
+            ).to(self._mm._d)
             
             with torch.no_grad():
-                outputs = self.model_manager.model(**inputs)
-                probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
+                _out = self._mm._m(**_inp)
+                _probs = torch.nn.functional.softmax(_out.logits, dim=-1).cpu().numpy()
             
-            for text, prob in zip(batch, probs):
-                sentiment = "Positive" if prob[1] > prob[0] else "Negative"
+            for _txt, _prob in zip(_b, _probs):
+                _sent = "Positive" if _prob[1] > _prob[0] else "Negative"
                 
-                results.append({
-                    'text': text[:50] + '...' if len(text) > 50 else text,
-                    'full_text': text,
-                    'sentiment': sentiment,
-                    'confidence': float(prob.max()),
-                    'pos_prob': float(prob[1]),
-                    'neg_prob': float(prob[0])
+                _res.append({
+                    'text': _txt[:50] + '...' if len(_txt) > 50 else _txt,
+                    'full_text': _txt,
+                    'sentiment': _sent,
+                    'confidence': float(_prob.max()),
+                    'pos_prob': float(_prob[1]),
+                    'neg_prob': float(_prob[0])
                 })
         
-        return results
+        return _res
 
-# Unified Visualization System
-class PlotFactory:
-    """Factory for creating plots with proper memory management"""
-    
+class _PF4:
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_sentiment_bars(probs: np.ndarray, theme: ThemeContext) -> plt.Figure:
-        """Create sentiment probability bars"""
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
-            labels = ["Negative", "Positive"]
-            colors = [theme.colors['neg'], theme.colors['pos']]
-            
-            bars = ax.bar(labels, probs, color=colors, alpha=0.8)
-            ax.set_title("Sentiment Probabilities", fontweight='bold')
-            ax.set_ylabel("Probability")
-            ax.set_ylim(0, 1)
-            
-            for bar, prob in zip(bars, probs):
-                ax.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.02,
-                       f'{prob:.3f}', ha='center', va='bottom', fontweight='bold')
-            
-            fig.tight_layout()
-            return fig
+    @_err_wrap(default_return=None)
+    def _bars(_probs: np.ndarray, _th: _Th7) -> plt.Figure:
+        with _fig_mgr(figsize=_cfg._fs1) as _f:
+            _ax = _f.add_subplot(111)
+            _lbl = ["Negative", "Positive"]
+            _clr = [_th._c['neg'], _th._c['pos']]
+            
+            _b = _ax.bar(_lbl, _probs, color=_clr, alpha=0.8)
+            _ax.set_title("Sentiment Probabilities", fontweight='bold')
+            _ax.set_ylabel("Probability")
+            _ax.set_ylim(0, 1)
+            
+            for _bar, _prob in zip(_b, _probs):
+                _ax.text(_bar.get_x() + _bar.get_width()/2., _bar.get_height() + 0.02,
+                       f'{_prob:.3f}', ha='center', va='bottom', fontweight='bold')
+            
+            _f.tight_layout()
+            return _f
     
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_confidence_gauge(confidence: float, sentiment: str, theme: ThemeContext) -> plt.Figure:
-        """Create confidence gauge"""
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
-            
-            theta = np.linspace(0, np.pi, 100)
-            colors = [theme.colors['neg'] if i < 50 else theme.colors['pos'] for i in range(100)]
-            
-            for i in range(len(theta)-1):
-                ax.fill_between([theta[i], theta[i+1]], [0, 0], [0.8, 0.8], 
-                               color=colors[i], alpha=0.7)
-            
-            pos = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
-            ax.plot([pos, pos], [0, 0.6], 'k-', linewidth=6)
-            ax.plot(pos, 0.6, 'ko', markersize=10)
-            
-            ax.set_xlim(0, np.pi)
-            ax.set_ylim(0, 1)
-            ax.set_title(f'{sentiment} - Confidence: {confidence:.3f}', fontweight='bold')
-            ax.set_xticks([0, np.pi/2, np.pi])
-            ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
-            ax.axis('off')
-            
-            fig.tight_layout()
-            return fig
+    @_err_wrap(default_return=None)
+    def _gauge(_conf: float, _sent: str, _th: _Th7) -> plt.Figure:
+        with _fig_mgr(figsize=_cfg._fs1) as _f:
+            _ax = _f.add_subplot(111)
+            
+            _theta = np.linspace(0, np.pi, 100)
+            _clr = [_th._c['neg'] if i < 50 else _th._c['pos'] for i in range(100)]
+            
+            for i in range(len(_theta)-1):
+                _ax.fill_between([_theta[i], _theta[i+1]], [0, 0], [0.8, 0.8], 
+                               color=_clr[i], alpha=0.7)
+            
+            _pos = np.pi * (0.5 + (0.4 if _sent == 'Positive' else -0.4) * _conf)
+            _ax.plot([_pos, _pos], [0, 0.6], 'k-', linewidth=6)
+            _ax.plot(_pos, 0.6, 'ko', markersize=10)
+            
+            _ax.set_xlim(0, np.pi)
+            _ax.set_ylim(0, 1)
+            _ax.set_title(f'{_sent} - Confidence: {_conf:.3f}', fontweight='bold')
+            _ax.set_xticks([0, np.pi/2, np.pi])
+            _ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
+            _ax.axis('off')
+            
+            _f.tight_layout()
+            return _f
     
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_lime_keyword_chart(lime_words: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
-        """Create horizontal bar chart for LIME key contributing words"""
-        if not lime_words:
+    @_err_wrap(default_return=None)
+    def _lime_chart(_lw: List[Tuple[str, float]], _sent: str, _th: _Th7) -> Optional[plt.Figure]:
+        if not _lw:
             return None
         
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
+        with _fig_mgr(figsize=_cfg._fs1) as _f:
+            _ax = _f.add_subplot(111)
             
-            words = [word for word, score in lime_words]
-            scores = [score for word, score in lime_words]
+            _w = [_word for _word, _score in _lw]
+            _s = [_score for _word, _score in _lw]
             
-            color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
+            _clr = _th._c['pos'] if _sent == 'Positive' else _th._c['neg']
             
-            bars = ax.barh(range(len(words)), scores, color=color, alpha=0.7)
-            ax.set_yticks(range(len(words)))
-            ax.set_yticklabels(words)
-            ax.set_xlabel('LIME Attention Weight')
-            ax.set_title(f'LIME: Top Contributing Words ({sentiment})', fontweight='bold')
+            _b = _ax.barh(range(len(_w)), _s, color=_clr, alpha=0.7)
+            _ax.set_yticks(range(len(_w)))
+            _ax.set_yticklabels(_w)
+            _ax.set_xlabel('LIME Attention Weight')
+            _ax.set_title(f'LIME: Top Contributing Words ({_sent})', fontweight='bold')
             
-            for i, (bar, score) in enumerate(zip(bars, scores)):
-                ax.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2.,
-                       f'{score:.3f}', ha='left', va='center', fontsize=9)
+            for i, (_bar, _score) in enumerate(zip(_b, _s)):
+                _ax.text(_bar.get_width() + 0.001, _bar.get_y() + _bar.get_height()/2.,
+                       f'{_score:.3f}', ha='left', va='center', fontsize=9)
             
-            ax.invert_yaxis()
-            ax.grid(axis='x', alpha=0.3)
-            fig.tight_layout()
-            return fig
+            _ax.invert_yaxis()
+            _ax.grid(axis='x', alpha=0.3)
+            _f.tight_layout()
+            return _f
     
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_shap_keyword_chart(shap_words: List[Tuple[str, float]], sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
-        """Create horizontal bar chart for SHAP key contributing words"""
-        if not shap_words:
+    @_err_wrap(default_return=None)
+    def _shap_chart(_sw: List[Tuple[str, float]], _sent: str, _th: _Th7) -> Optional[plt.Figure]:
+        if not _sw:
             return None
         
-        with managed_figure(figsize=config.FIGURE_SIZE_SINGLE) as fig:
-            ax = fig.add_subplot(111)
+        with _fig_mgr(figsize=_cfg._fs1) as _f:
+            _ax = _f.add_subplot(111)
             
-            words = [word for word, score in shap_words]
-            scores = [score for word, score in shap_words]
+            _w = [_word for _word, _score in _sw]
+            _s = [_score for _word, _score in _sw]
             
-            color = theme.colors['pos'] if sentiment == 'Positive' else theme.colors['neg']
+            _clr = _th._c['pos'] if _sent == 'Positive' else _th._c['neg']
             
-            bars = ax.barh(range(len(words)), scores, color=color, alpha=0.7)
-            ax.set_yticks(range(len(words)))
-            ax.set_yticklabels(words)
-            ax.set_xlabel('SHAP Value')
-            ax.set_title(f'SHAP: Top Contributing Words ({sentiment})', fontweight='bold')
+            _b = _ax.barh(range(len(_w)), _s, color=_clr, alpha=0.7)
+            _ax.set_yticks(range(len(_w)))
+            _ax.set_yticklabels(_w)
+            _ax.set_xlabel('SHAP Value')
+            _ax.set_title(f'SHAP: Top Contributing Words ({_sent})', fontweight='bold')
             
-            for i, (bar, score) in enumerate(zip(bars, scores)):
-                ax.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2.,
-                       f'{score:.3f}', ha='left', va='center', fontsize=9)
+            for i, (_bar, _score) in enumerate(zip(_b, _s)):
+                _ax.text(_bar.get_width() + 0.001, _bar.get_y() + _bar.get_height()/2.,
+                       f'{_score:.3f}', ha='left', va='center', fontsize=9)
             
-            ax.invert_yaxis()
-            ax.grid(axis='x', alpha=0.3)
-            fig.tight_layout()
-            return fig
+            _ax.invert_yaxis()
+            _ax.grid(axis='x', alpha=0.3)
+            _f.tight_layout()
+            return _f
     
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_wordcloud(text: str, sentiment: str, theme: ThemeContext) -> Optional[plt.Figure]:
-        """Create word cloud"""
-        if len(text.split()) < 3:
+    @_err_wrap(default_return=None)
+    def _cloud(_txt: str, _sent: str, _th: _Th7) -> Optional[plt.Figure]:
+        if len(_txt.split()) < 3:
             return None
         
-        colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
-        wc = WordCloud(width=800, height=400, background_color='white',
-                      colormap=colormap, max_words=30).generate(text)
-        
-        with managed_figure(figsize=config.WORDCLOUD_SIZE) as fig:
-            ax = fig.add_subplot(111)
-            ax.imshow(wc, interpolation='bilinear')
-            ax.axis('off')
-            ax.set_title(f'{sentiment} Word Cloud', fontweight='bold')
-            fig.tight_layout()
-            return fig
+        _cm = 'Greens' if _sent == 'Positive' else 'Reds'
+        _wc = WordCloud(width=800, height=400, background_color='white',
+                      colormap=_cm, max_words=30).generate(_txt)
+        
+        with _fig_mgr(figsize=_cfg._ws) as _f:
+            _ax = _f.add_subplot(111)
+            _ax.imshow(_wc, interpolation='bilinear')
+            _ax.axis('off')
+            _ax.set_title(f'{_sent} Word Cloud', fontweight='bold')
+            _f.tight_layout()
+            return _f
     
     @staticmethod
-    @handle_errors(default_return=None)
-    def create_batch_analysis(results: List[Dict], theme: ThemeContext) -> plt.Figure:
-        """Create comprehensive batch visualization"""
-        with managed_figure(figsize=config.FIGURE_SIZE_BATCH) as fig:
-            gs = fig.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
-            
-            # Sentiment distribution
-            ax1 = fig.add_subplot(gs[0, 0])
-            sent_counts = Counter([r['sentiment'] for r in results])
-            colors = [theme.colors['pos'], theme.colors['neg']]
-            ax1.pie(sent_counts.values(), labels=sent_counts.keys(), 
-                   autopct='%1.1f%%', colors=colors[:len(sent_counts)])
-            ax1.set_title('Sentiment Distribution')
-            
-            # Confidence histogram
-            ax2 = fig.add_subplot(gs[0, 1])
-            confs = [r['confidence'] for r in results]
-            ax2.hist(confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
-            ax2.set_title('Confidence Distribution')
-            ax2.set_xlabel('Confidence')
-            
-            # Sentiment over time
-            ax3 = fig.add_subplot(gs[1, :])
-            pos_probs = [r['pos_prob'] for r in results]
-            indices = range(len(results))
-            colors_scatter = [theme.colors['pos'] if r['sentiment'] == 'Positive' 
-                            else theme.colors['neg'] for r in results]
-            ax3.scatter(indices, pos_probs, c=colors_scatter, alpha=0.7, s=60)
-            ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
-            ax3.set_title('Sentiment Progression')
-            ax3.set_xlabel('Review Index')
-            ax3.set_ylabel('Positive Probability')
-            
-            return fig
+    @_err_wrap(default_return=None)
+    def _batch_viz(_res: List[Dict], _th: _Th7) -> plt.Figure:
+        with _fig_mgr(figsize=_cfg._fs2) as _f:
+            _gs = _f.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
+            
+            _ax1 = _f.add_subplot(_gs[0, 0])
+            _sc = Counter([_r['sentiment'] for _r in _res])
+            _clr = [_th._c['pos'], _th._c['neg']]
+            _ax1.pie(_sc.values(), labels=_sc.keys(), 
+                   autopct='%1.1f%%', colors=_clr[:len(_sc)])
+            _ax1.set_title('Sentiment Distribution')
+            
+            _ax2 = _f.add_subplot(_gs[0, 1])
+            _confs = [_r['confidence'] for _r in _res]
+            _ax2.hist(_confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
+            _ax2.set_title('Confidence Distribution')
+            _ax2.set_xlabel('Confidence')
+            
+            _ax3 = _f.add_subplot(_gs[1, :])
+            _pp = [_r['pos_prob'] for _r in _res]
+            _idx = range(len(_res))
+            _cs = [_th._c['pos'] if _r['sentiment'] == 'Positive' 
+                            else _th._c['neg'] for _r in _res]
+            _ax3.scatter(_idx, _pp, c=_cs, alpha=0.7, s=60)
+            _ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+            _ax3.set_title('Sentiment Progression')
+            _ax3.set_xlabel('Review Index')
+            _ax3.set_ylabel('Positive Probability')
+            
+            return _f
 
-class DataHandler:
-    """Handles all data operations"""
-    
+class _DH5:
     @staticmethod
-    @handle_errors(default_return=(None, "Export failed"))
-    def export_data(data: List[Dict], format_type: str) -> Tuple[Optional[str], str]:
-        """Universal data export"""
-        if not data:
+    @_err_wrap(default_return=(None, "Export failed"))
+    def _exp(_data: List[Dict], _fmt: str) -> Tuple[Optional[str], str]:
+        if not _data:
             return None, "No data to export"
         
-        temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, 
-                                               suffix=f'.{format_type}', encoding='utf-8')
-        
-        if format_type == 'csv':
-            writer = csv.writer(temp_file)
-            writer.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Pos_Prob', 'Neg_Prob'])
-            for entry in data:
-                writer.writerow([
-                    entry.get('timestamp', ''),
-                    entry.get('text', ''),
-                    entry.get('sentiment', ''),
-                    f"{entry.get('confidence', 0):.4f}",
-                    f"{entry.get('pos_prob', 0):.4f}",
-                    f"{entry.get('neg_prob', 0):.4f}"
+        _tf = tempfile.NamedTemporaryFile(mode='w', delete=False, 
+                                               suffix=f'.{_fmt}', encoding='utf-8')
+        
+        if _fmt == 'csv':
+            _w = csv.writer(_tf)
+            _w.writerow(['Timestamp', 'Text', 'Sentiment', 'Confidence', 'Pos_Prob', 'Neg_Prob'])
+            for _e in _data:
+                _w.writerow([
+                    _e.get('timestamp', ''),
+                    _e.get('text', ''),
+                    _e.get('sentiment', ''),
+                    f"{_e.get('confidence', 0):.4f}",
+                    f"{_e.get('pos_prob', 0):.4f}",
+                    f"{_e.get('neg_prob', 0):.4f}"
                 ])
-        elif format_type == 'json':
-            json.dump(data, temp_file, indent=2, ensure_ascii=False)
+        elif _fmt == 'json':
+            json.dump(_data, _tf, indent=2, ensure_ascii=False)
         
-        temp_file.close()
-        return temp_file.name, f"Exported {len(data)} entries"
+        _tf.close()
+        return _tf.name, f"Exported {len(_data)} entries"
     
     @staticmethod
-    @handle_errors(default_return="")
-    def process_file(file) -> str:
-        """Process uploaded file with improved CSV handling"""
-        if not file:
+    @_err_wrap(default_return="")
+    def _proc(_file) -> str:
+        if not _file:
             return ""
         
         try:
-            file_path = file.name
+            _fp = _file.name
             
-            if file_path.endswith('.csv'):
-                for encoding in ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']:
+            if _fp.endswith('.csv'):
+                for _enc in ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']:
                     try:
-                        df = pd.read_csv(file_path, encoding=encoding)
+                        _df = pd.read_csv(_fp, encoding=_enc)
                         
-                        text_columns = []
-                        for col in df.columns:
-                            sample_values = df[col].dropna().head(10)
-                            if len(sample_values) > 0:
-                                text_count = sum(1 for val in sample_values 
-                                               if isinstance(val, str) and len(str(val).strip()) > 10)
-                                if text_count > len(sample_values) * 0.7:
-                                    text_columns.append(col)
+                        _tc = []
+                        for _col in _df.columns:
+                            _sv = _df[_col].dropna().head(10)
+                            if len(_sv) > 0:
+                                _cnt = sum(1 for _val in _sv 
+                                               if isinstance(_val, str) and len(str(_val).strip()) > 10)
+                                if _cnt > len(_sv) * 0.7:
+                                    _tc.append(_col)
                         
-                        if text_columns:
-                            selected_column = text_columns[0]
+                        if _tc:
+                            _sc = _tc[0]
                         else:
-                            selected_column = df.columns[0]
+                            _sc = _df.columns[0]
                         
-                        reviews = df[selected_column].dropna().astype(str).tolist()
+                        _rev = _df[_sc].dropna().astype(str).tolist()
                         
-                        cleaned_reviews = []
-                        for review in reviews:
-                            review = review.strip()
-                            if len(review) > 10 and review.lower() != 'nan':
-                                cleaned_reviews.append(review)
+                        _cr = []
+                        for _r in _rev:
+                            _r = _r.strip()
+                            if len(_r) > 10 and _r.lower() != 'nan':
+                                _cr.append(_r)
                         
-                        if cleaned_reviews:
-                            logger.info(f"Successfully read {len(cleaned_reviews)} reviews from CSV")
-                            return '\n'.join(cleaned_reviews)
+                        if _cr:
+                            _log.info(f"Successfully read {len(_cr)} reviews from CSV")
+                            return '\n'.join(_cr)
                             
                     except Exception as e:
                         continue
@@ -596,31 +554,28 @@ class DataHandler:
                 return "Error: Could not read CSV file. Please check the file format and encoding."
             
             else:
-                for encoding in ['utf-8', 'latin-1', 'cp1252']:
+                for _enc in ['utf-8', 'latin-1', 'cp1252']:
                     try:
-                        with open(file_path, 'r', encoding=encoding) as f:
-                            content = f.read().strip()
-                        if content:
-                            return content
+                        with open(_fp, 'r', encoding=_enc) as _f:
+                            _cont = _f.read().strip()
+                        if _cont:
+                            return _cont
                     except Exception as e:
                         continue
                 
                 return "Error: Could not read text file. Please check the file encoding."
                 
         except Exception as e:
-            logger.error(f"File processing error: {e}")
+            _log.error(f"File processing error: {e}")
             return f"Error processing file: {str(e)}"
 
-# Main Application
-class SentimentApp:
-    """Main application orchestrator"""
-    
+class _SA6:
     def __init__(self):
-        self.engine = SentimentEngine()
-        self.history = HistoryManager()
-        self.data_handler = DataHandler()
+        self._eng = _SE3()
+        self._hist = _HM2()
+        self._dh = _DH5()
         
-        self.examples = [
+        self._ex = [
             ["While the film's visual effects were undeniably impressive, the story lacked emotional weight, and the pacing felt inconsistent throughout."],
             ["An extraordinary achievement in filmmaking — the direction was masterful, the script was sharp, and every performance added depth and realism."],
             ["Despite a promising start, the film quickly devolved into a series of clichés, with weak character development and an ending that felt rushed and unearned."],
@@ -628,259 +583,246 @@ class SentimentApp:
             ["The movie was far too long, with unnecessary subplots and dull dialogue that made it difficult to stay engaged until the end."]
         ]
     
-    @handle_errors(default_return=("Please enter text", None, None, None))
-    def analyze_single_fast(self, text: str, theme: str = 'default'):
-        """Fast single text analysis without keywords"""
-        if not text.strip():
+    @_err_wrap(default_return=("Please enter text", None, None, None))
+    def _fast_ana(self, _txt: str, _th: str = 'default'):
+        if not _txt.strip():
             return "Please enter text", None, None, None
         
-        result = self.engine.analyze_single_fast(text)
+        _res = self._eng._fast(_txt)
         
-        self.history.add({
-            'text': text[:100],
-            'full_text': text,
-            **result
+        self._hist._add({
+            'text': _txt[:100],
+            'full_text': _txt,
+            **_res
         })
         
-        theme_ctx = ThemeContext(theme)
-        probs = np.array([result['neg_prob'], result['pos_prob']])
+        _thc = _Th7(_th)
+        _probs = np.array([_res['neg_prob'], _res['pos_prob']])
         
-        prob_plot = PlotFactory.create_sentiment_bars(probs, theme_ctx)
-        gauge_plot = PlotFactory.create_confidence_gauge(result['confidence'], result['sentiment'], theme_ctx)
-        cloud_plot = PlotFactory.create_wordcloud(text, result['sentiment'], theme_ctx)
+        _pp = _PF4._bars(_probs, _thc)
+        _gp = _PF4._gauge(_res['confidence'], _res['sentiment'], _thc)
+        _cp = _PF4._cloud(_txt, _res['sentiment'], _thc)
         
-        result_text = f"Sentiment: {result['sentiment']} (Confidence: {result['confidence']:.3f})"
+        _rt = f"Sentiment: {_res['sentiment']} (Confidence: {_res['confidence']:.3f})"
         
-        return result_text, prob_plot, gauge_plot, cloud_plot
+        return _rt, _pp, _gp, _cp
     
-    @handle_errors(default_return=("Please enter text", None, None, None))
-    def analyze_single_advanced(self, text: str, theme: str = 'default'):
-        """Advanced single text analysis with LIME and SHAP explanation"""
-        if not text.strip():
+    @_err_wrap(default_return=("Please enter text", None, None, None))
+    def _adv_ana(self, _txt: str, _th: str = 'default'):
+        if not _txt.strip():
             return "Please enter text", None, None, None
         
-        result = self.engine.analyze_single_advanced(text)
+        _res = self._eng._adv(_txt)
         
-        self.history.add({
-            'text': text[:100],
-            'full_text': text,
-            **result
+        self._hist._add({
+            'text': _txt[:100],
+            'full_text': _txt,
+            **_res
         })
         
-        theme_ctx = ThemeContext(theme)
+        _thc = _Th7(_th)
         
-        lime_plot = PlotFactory.create_lime_keyword_chart(result['lime_words'], result['sentiment'], theme_ctx)
-        shap_plot = PlotFactory.create_shap_keyword_chart(result['shap_words'], result['sentiment'], theme_ctx)
+        _lp = _PF4._lime_chart(_res['lime_words'], _res['sentiment'], _thc)
+        _sp = _PF4._shap_chart(_res['shap_words'], _res['sentiment'], _thc)
         
-        lime_words_str = ", ".join([f"{word}({score:.3f})" for word, score in result['lime_words'][:5]])
-        shap_words_str = ", ".join([f"{word}({score:.3f})" for word, score in result['shap_words'][:5]])
+        _lws = ", ".join([f"{_w}({_s:.3f})" for _w, _s in _res['lime_words'][:5]])
+        _sws = ", ".join([f"{_w}({_s:.3f})" for _w, _s in _res['shap_words'][:5]])
         
-        result_text = (f"Sentiment: {result['sentiment']} (Confidence: {result['confidence']:.3f})\n"
-                      f"LIME Key Words: {lime_words_str}\n"
-                      f"SHAP Key Words: {shap_words_str}")
+        _rt = (f"Sentiment: {_res['sentiment']} (Confidence: {_res['confidence']:.3f})\n"
+                      f"LIME Key Words: {_lws}\n"
+                      f"SHAP Key Words: {_sws}")
         
-        return result_text, lime_plot, shap_plot, result['heatmap_html']
+        return _rt, _lp, _sp, _res['heatmap_html']
     
-    @handle_errors(default_return=None)
-    def analyze_batch(self, reviews: str, progress=None):
-        """Batch analysis"""
-        if not reviews.strip():
+    @_err_wrap(default_return=None)
+    def _batch_ana(self, _revs: str, _prog=None):
+        if not _revs.strip():
             return None
         
-        texts = [r.strip() for r in reviews.split('\n') if r.strip()]
-        if len(texts) < 2:
+        _txts = [_r.strip() for _r in _revs.split('\n') if _r.strip()]
+        if len(_txts) < 2:
             return None
         
-        results = self.engine.analyze_batch(texts, progress)
+        _res = self._eng._batch(_txts, _prog)
         
-        for result in results:
-            self.history.add(result)
+        for _r in _res:
+            self._hist._add(_r)
         
-        theme_ctx = ThemeContext('default')
-        return PlotFactory.create_batch_analysis(results, theme_ctx)
+        _thc = _Th7('default')
+        return _PF4._batch_viz(_res, _thc)
     
-    @handle_errors(default_return=(None, "No history available"))
-    def plot_history(self, theme: str = 'default'):
-        """Plot analysis history"""
-        history = self.history.get_all()
-        if len(history) < 2:
-            return None, f"Need at least 2 analyses for trends. Current: {len(history)}"
-        
-        theme_ctx = ThemeContext(theme)
-        
-        with managed_figure(figsize=(12, 8)) as fig:
-            gs = fig.add_gridspec(2, 1, hspace=0.3)
-            
-            indices = list(range(len(history)))
-            pos_probs = [item['pos_prob'] for item in history]
-            confs = [item['confidence'] for item in history]
-            
-            # Sentiment trend
-            ax1 = fig.add_subplot(gs[0, 0])
-            colors = [theme_ctx.colors['pos'] if p > 0.5 else theme_ctx.colors['neg'] 
-                     for p in pos_probs]
-            ax1.scatter(indices, pos_probs, c=colors, alpha=0.7, s=60)
-            ax1.plot(indices, pos_probs, alpha=0.5, linewidth=2)
-            ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
-            ax1.set_title('Sentiment History')
-            ax1.set_ylabel('Positive Probability')
-            ax1.grid(True, alpha=0.3)
-            
-            # Confidence trend
-            ax2 = fig.add_subplot(gs[1, 0])
-            ax2.bar(indices, confs, alpha=0.7, color='lightblue', edgecolor='navy')
-            ax2.set_title('Confidence Over Time')
-            ax2.set_xlabel('Analysis Number')
-            ax2.set_ylabel('Confidence')
-            ax2.grid(True, alpha=0.3)
-            
-            fig.tight_layout()
-            return fig, f"History: {len(history)} analyses"
+    @_err_wrap(default_return=(None, "No history available"))
+    def _hist_plot(self, _th: str = 'default'):
+        _hist = self._hist._get()
+        if len(_hist) < 2:
+            return None, f"Need at least 2 analyses for trends. Current: {len(_hist)}"
+        
+        _thc = _Th7(_th)
+        
+        with _fig_mgr(figsize=(12, 8)) as _f:
+            _gs = _f.add_gridspec(2, 1, hspace=0.3)
+            
+            _idx = list(range(len(_hist)))
+            _pp = [_item['pos_prob'] for _item in _hist]
+            _confs = [_item['confidence'] for _item in _hist]
+            
+            _ax1 = _f.add_subplot(_gs[0, 0])
+            _clr = [_thc._c['pos'] if _p > 0.5 else _thc._c['neg'] 
+                     for _p in _pp]
+            _ax1.scatter(_idx, _pp, c=_clr, alpha=0.7, s=60)
+            _ax1.plot(_idx, _pp, alpha=0.5, linewidth=2)
+            _ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+            _ax1.set_title('Sentiment History')
+            _ax1.set_ylabel('Positive Probability')
+            _ax1.grid(True, alpha=0.3)
+            
+            _ax2 = _f.add_subplot(_gs[1, 0])
+            _ax2.bar(_idx, _confs, alpha=0.7, color='lightblue', edgecolor='navy')
+            _ax2.set_title('Confidence Over Time')
+            _ax2.set_xlabel('Analysis Number')
+            _ax2.set_ylabel('Confidence')
+            _ax2.grid(True, alpha=0.3)
+            
+            _f.tight_layout()
+            return _f, f"History: {len(_hist)} analyses"
 
-# Gradio Interface Setup
-def create_interface():
-    """Create streamlined Gradio interface"""
-    app = SentimentApp()
+def _create_ui():
+    _app = _SA6()
     
-    with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as demo:
+    with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as _demo:
         gr.Markdown("# 🎬 AI Movie Sentiment Analyzer")
         gr.Markdown("Fast sentiment analysis with advanced deep learning explanations")
         
         with gr.Tab("Quick Analysis"):
             with gr.Row():
                 with gr.Column():
-                    text_input = gr.Textbox(
+                    _ti = gr.Textbox(
                         label="Movie Review",
                         placeholder="Enter your movie review...",
                         lines=5
                     )
                     with gr.Row():
-                        analyze_btn = gr.Button("Analyze", variant="primary")
-                        theme_selector = gr.Dropdown(
-                            choices=list(config.THEMES.keys()),
+                        _ab = gr.Button("Analyze", variant="primary")
+                        _ts = gr.Dropdown(
+                            choices=list(_cfg._th.keys()),
                             value="default",
                             label="Theme"
                         )
                     
                     gr.Examples(
-                        examples=app.examples,
-                        inputs=text_input
+                        examples=_app._ex,
+                        inputs=_ti
                     )
                 
                 with gr.Column():
-                    result_output = gr.Textbox(label="Result", lines=3)
+                    _ro = gr.Textbox(label="Result", lines=3)
             
             with gr.Row():
-                prob_plot = gr.Plot(label="Probabilities")
-                gauge_plot = gr.Plot(label="Confidence")
+                _pp = gr.Plot(label="Probabilities")
+                _gp = gr.Plot(label="Confidence")
             
             with gr.Row():
-                wordcloud_plot = gr.Plot(label="Word Cloud")
+                _wp = gr.Plot(label="Word Cloud")
         
         with gr.Tab("Advanced Analysis"):
             with gr.Row():
                 with gr.Column():
-                    adv_text_input = gr.Textbox(
+                    _ati = gr.Textbox(
                         label="Movie Review",
                         placeholder="Enter your movie review for deep analysis...",
                         lines=5
                     )
                     with gr.Row():
-                        adv_analyze_btn = gr.Button("Deep Analyze", variant="primary")
-                        adv_theme_selector = gr.Dropdown(
-                            choices=list(config.THEMES.keys()),
+                        _aab = gr.Button("Deep Analyze", variant="primary")
+                        _ats = gr.Dropdown(
+                            choices=list(_cfg._th.keys()),
                             value="default",
                             label="Theme"
                         )
                     
                     gr.Examples(
-                        examples=app.examples,
-                        inputs=adv_text_input
+                        examples=_app._ex,
+                        inputs=_ati
                     )
                 
                 with gr.Column():
-                    adv_result_output = gr.Textbox(label="Analysis Result", lines=4)
+                    _aro = gr.Textbox(label="Analysis Result", lines=4)
             
             with gr.Row():
-                lime_plot = gr.Plot(label="LIME: Key Contributing Words")
-                shap_plot = gr.Plot(label="SHAP: Key Contributing Words")
+                _lp = gr.Plot(label="LIME: Key Contributing Words")
+                _sp = gr.Plot(label="SHAP: Key Contributing Words")
             
             with gr.Row():
-                heatmap_output = gr.HTML(label="Word Importance Heatmap (LIME-based)")
+                _ho = gr.HTML(label="Word Importance Heatmap (LIME-based)")
         
         with gr.Tab("Batch Analysis"):
             with gr.Row():
                 with gr.Column():
-                    file_upload = gr.File(label="Upload File", file_types=[".csv", ".txt"])
-                    batch_input = gr.Textbox(
+                    _fu = gr.File(label="Upload File", file_types=[".csv", ".txt"])
+                    _bi = gr.Textbox(
                         label="Reviews (one per line)",
                         lines=8
                     )
                 
                 with gr.Column():
-                    load_btn = gr.Button("Load File")
-                    batch_btn = gr.Button("Analyze Batch", variant="primary")
+                    _lb = gr.Button("Load File")
+                    _bb = gr.Button("Analyze Batch", variant="primary")
             
-            batch_plot = gr.Plot(label="Batch Results")
+            _bp = gr.Plot(label="Batch Results")
         
         with gr.Tab("History & Export"):
             with gr.Row():
-                refresh_btn = gr.Button("Refresh")
-                clear_btn = gr.Button("Clear", variant="stop")
+                _rb = gr.Button("Refresh")
+                _cb = gr.Button("Clear", variant="stop")
             
             with gr.Row():
-                csv_btn = gr.Button("Export CSV")
-                json_btn = gr.Button("Export JSON")
-            
-            history_status = gr.Textbox(label="Status")
-            history_plot = gr.Plot(label="History Trends")
-            csv_file = gr.File(label="CSV Download", visible=True)
-            json_file = gr.File(label="JSON Download", visible=True)
-        
-        # Event bindings for Quick Analysis
-        analyze_btn.click(
-            app.analyze_single_fast,
-            inputs=[text_input, theme_selector],
-            outputs=[result_output, prob_plot, gauge_plot, wordcloud_plot]
+                _csvb = gr.Button("Export CSV")
+                _jb = gr.Button("Export JSON")
+            
+            _hs = gr.Textbox(label="Status")
+            _hp = gr.Plot(label="History Trends")
+            _csvf = gr.File(label="CSV Download", visible=True)
+            _jf = gr.File(label="JSON Download", visible=True)
+        
+        _ab.click(
+            _app._fast_ana,
+            inputs=[_ti, _ts],
+            outputs=[_ro, _pp, _gp, _wp]
         )
         
-        # Event bindings for Advanced Analysis
-        adv_analyze_btn.click(
-            app.analyze_single_advanced,
-            inputs=[adv_text_input, adv_theme_selector],
-            outputs=[adv_result_output, lime_plot, shap_plot, heatmap_output]
+        _aab.click(
+            _app._adv_ana,
+            inputs=[_ati, _ats],
+            outputs=[_aro, _lp, _sp, _ho]
         )
         
-        # Event bindings for Batch Analysis
-        load_btn.click(app.data_handler.process_file, inputs=file_upload, outputs=batch_input)
-        batch_btn.click(app.analyze_batch, inputs=batch_input, outputs=batch_plot)
+        _lb.click(_app._dh._proc, inputs=_fu, outputs=_bi)
+        _bb.click(_app._batch_ana, inputs=_bi, outputs=_bp)
         
-        # Event bindings for History & Export
-        refresh_btn.click(
-            lambda theme: app.plot_history(theme),
-            inputs=theme_selector,
-            outputs=[history_plot, history_status]
+        _rb.click(
+            lambda _th: _app._hist_plot(_th),
+            inputs=_ts,
+            outputs=[_hp, _hs]
         )
         
-        clear_btn.click(
-            lambda: f"Cleared {app.history.clear()} entries",
-            outputs=history_status
+        _cb.click(
+            lambda: f"Cleared {_app._hist._clr()} entries",
+            outputs=_hs
         )
         
-        csv_btn.click(
-            lambda: app.data_handler.export_data(app.history.get_all(), 'csv'),
-            outputs=[csv_file, history_status]
+        _csvb.click(
+            lambda: _app._dh._exp(_app._hist._get(), 'csv'),
+            outputs=[_csvf, _hs]
         )
         
-        json_btn.click(
-            lambda: app.data_handler.export_data(app.history.get_all(), 'json'),
-            outputs=[json_file, history_status]
+        _jb.click(
+            lambda: _app._dh._exp(_app._hist._get(), 'json'),
+            outputs=[_jf, _hs]
         )
     
-    return demo
+    return _demo
 
-# Application Entry Point
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
-    demo = create_interface()
-    demo.launch(share=True)
+    _demo = _create_ui()
+    _demo.launch(share=True)