Update pine_parser.py

pine_parser.py

@@ -1,120 +1,158 @@
-import streamlit as st
-from pine_parser import PineScriptParser
-import os
-from dotenv import load_dotenv
+import re
+from typing import List, Dict, Optional, Tuple
+import numpy as np
 
-# Load environment variables
-load_dotenv()
-
-# Configure page
-st.set_page_config(
-    page_title="Pine Script Analyzer Pro",
-    page_icon="🧠",
-    layout="wide"
-)
-
-# Custom CSS for better UI
-st.markdown("""
-<style>
-.code-container {
-    border-radius: 0.5rem;
-    padding: 1rem;
-    background-color: #f8f9fa;
-    border: 1px solid #dee2e6;
-}
-.fixed-code {
-    background-color: #e8f5e9;
-}
-.error-message {
-    color: #d32f2f;
-    font-weight: bold;
-}
-.warning-message {
-    color: #ffa000;
-}
-</style>
-""", unsafe_allow_html=True)
-
-def main():
-    st.title("🧠 Pine Script Analyzer Pro")
-    st.caption("Professional-grade analysis and optimization for TradingView Pine Script")
-    
-    with st.expander("📝 Paste Your Pine Script Code", expanded=True):
-        user_code = st.text_area(
-            "Paste your Pine Script code here:",
-            height=300,
-            placeholder="""//@version=5
-indicator("My Indicator")
-plot(close)""",
-            label_visibility="collapsed"
-        )
-
-    if st.button("🔍 Analyze & Optimize Code", use_container_width=True):
-        if not user_code.strip():
-            st.error("Please enter Pine Script code to analyze")
-        else:
-            with st.spinner("Analyzing code with professional-grade tools..."):
-                try:
-                    parser = PineScriptParser(user_code)
-                    results = {
-                        "version": parser.detect_version() or "Unknown",
-                        "errors": parser.find_errors(),
-                        "warnings": parser.find_warnings(),
-                        "optimizations": parser.find_optimizations(),
-                        "fixed_code": parser.generate_fixed_code()
-                    }
-                    
-                    display_results(results)
-                    
-                except Exception as e:
-                    st.error(f"Professional analysis failed: {str(e)}")
-
-def display_results(results):
-    """Display analysis results in professional UI"""
+class PineScriptParser:
+    """Professional-grade Pine Script analyzer with advanced features"""
     
-    # Version and summary
-    col1, col2 = st.columns(2)
-    with col1:
-        st.metric("Detected Version", results["version"])
-    with col2:
-        st.metric("Issues Found", f"{len(results['errors'])} Errors, {len(results['warnings'])} Warnings")
+    def __init__(self, code: str):
+        self.original_code = code
+        self.code = code.strip()
+        self.version = self._detect_version()
+        self.errors: List[str] = []
+        self.warnings: List[str] = []
+        self.optimizations: List[str] = []
+        self.formatting_issues: List[str] = []
+        self._analyzed = False
+        
+    def _detect_version(self) -> Optional[str]:
+        """Detect Pine Script version with advanced pattern matching"""
+        patterns = [
+            r'//\s*@version\s*=\s*(\d+)',
+            r'//\s*version\s*=\s*(\d+)',
+            r'@version\s*(\d+)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, self.code, re.IGNORECASE)
+            if match:
+                version = match.group(1)
+                if version in ['4', '5', '6']:
+                    return version
+        return None
+        
+    def _full_analysis(self):
+        """Comprehensive code analysis"""
+        if self._analyzed:
+            return
+            
+        self._check_syntax()
+        self._check_semantics()
+        self._check_performance()
+        self._check_formatting()
+        self._analyzed = True
     
-    # Tabs for different analysis aspects
-    tab1, tab2, tab3, tab4 = st.tabs(["🚨 Errors", "⚠️ Warnings", "✨ Optimizations", "✅ Fixed Code"])
+    def find_errors(self) -> List[str]:
+        """Find all syntax and semantic errors"""
+        self._full_analysis()
+        return self.errors
+        
+    def find_warnings(self) -> List[str]:
+        """Find all warnings and deprecations"""
+        self._full_analysis()
+        return self.warnings
+        
+    def find_optimizations(self) -> List[str]:
+        """Find performance optimization opportunities"""
+        self._full_analysis()
+        return self.optimizations
+        
+    def get_formatting_suggestions(self) -> List[str]:
+        """Get professional formatting recommendations"""
+        self._full_analysis()
+        return self.formatting_issues
+        
+    def _check_syntax(self):
+        """Advanced syntax validation"""
+        # Check for version declaration
+        if not self.version:
+            self.errors.append("Critical: Missing version declaration (//@version=X)")
+        
+        # Check for required components
+        required_patterns = [
+            (r'(indicator|strategy)\s*\(', "Missing indicator/strategy declaration"),
+            (r'plot|barcolor|fill', "No output functions found (plot, barcolor, etc.)")
+        ]
+        
+        for pattern, message in required_patterns:
+            if not re.search(pattern, self.code):
+                self.warnings.append(message)
+        
+        # Check bracket balance
+        if self.code.count('(') != self.code.count(')'):
+            self.errors.append("Syntax Error: Unbalanced parentheses")
+            
+        if self.code.count('[') != self.code.count(']'):
+            self.errors.append("Syntax Error: Unbalanced square brackets")
+            
+        if self.code.count('{') != self.code.count('}'):
+            self.errors.append("Syntax Error: Unbalanced curly braces")
     
-    with tab1:
-        if results["errors"]:
-            for error in results["errors"]:
-                st.markdown(f'<p class="error-message">• {error}</p>', unsafe_allow_html=True)
-        else:
-            st.success("No critical errors found!")
+    def _check_semantics(self):
+        """Deep semantic analysis"""
+        # Check for common semantic issues
+        if re.search(r'close\s*[+\-*/]\s*open', self.code):
+            self.optimizations.append("Consider using 'close - open' instead of arithmetic operations for better performance")
+            
+        if re.search(r'length\s*=\s*\d+', self.code):
+            self.warnings.append("Warning: Hardcoded lengths should be configurable via inputs")
+            
+        # Check for version-specific issues
+        if self.version == '4':
+            if re.search(r'request\.', self.code):
+                self.errors.append("Error: request.* functions are not available in v4")
     
-    with tab2:
-        if results["warnings"]:
-            for warning in results["warnings"]:
-                st.markdown(f'<p class="warning-message">• {warning}</p>', unsafe_allow_html=True)
-        else:
-            st.success("No warnings detected!")
+    def _check_performance(self):
+        """Performance optimization checks"""
+        # Check for inefficient loops
+        if re.search(r'for\s+i\s+from\s+\d+\s+to\s+\d+', self.code):
+            self.optimizations.append("Optimization: Consider using array functions instead of for-loops for better performance")
+            
+        # Check for redundant calculations
+        if re.search(r'sma\(sma\(', self.code):
+            self.optimizations.append("Optimization: Nested SMA calls can be combined for better efficiency")
     
-    with tab3:
-        if results["optimizations"]:
-            for opt in results["optimizations"]:
-                st.info(f"• {opt}")
-        else:
-            st.success("Code is already optimized!")
+    def _check_formatting(self):
+        """Professional formatting checks"""
+        lines = self.code.split('\n')
+        
+        # Check indentation
+        indent_problems = 0
+        for i, line in enumerate(lines):
+            if line.strip() and not line.startswith('    '):
+                indent_problems += 1
+                
+        if indent_problems > len(lines) * 0.1:  # More than 10% lines have issues
+            self.formatting_issues.append(f"Formatting: {indent_problems} lines with incorrect indentation (recommend 4 spaces)")
+        
+        # Check line length
+        long_lines = [i+1 for i, line in enumerate(lines) if len(line) > 120]
+        if long_lines:
+            self.formatting_issues.append(f"Formatting: Long lines detected (lines: {', '.join(map(str, long_lines))})")
     
-    with tab4:
-        st.markdown('<div class="code-container fixed-code">', unsafe_allow_html=True)
-        st.code(results["fixed_code"], language="javascript")
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-        st.download_button(
-            "📋 Download Optimized Code",
-            data=results["fixed_code"],
-            file_name="optimized_script.pine",
-            mime="text/plain",
-            use_container_width=True
-        )
-
-if __name__ == "__main__":
-    main()
+    def generate_fixed_code(self) -> str:
+        """Generate professionally formatted and optimized code"""
+        self._full_analysis()
+        
+        # Basic formatting fixes
+        fixed_code = []
+        lines = self.original_code.split('\n')
+        
+        # Apply consistent indentation
+        indent_level = 0
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith(('if', 'for', 'while', 'else')) and stripped.endswith(':'):
+                fixed_code.append('    ' * indent_level + stripped)
+                indent_level += 1
+            elif stripped in ('end', 'else'):
+                indent_level = max(0, indent_level - 1)
+                fixed_code.append('    ' * indent_level + stripped)
+            else:
+                fixed_code.append('    ' * indent_level + stripped)
+        
+        # Ensure version declaration
+        if not self.version:
+            fixed_code.insert(0, "//@version=5")
+        
+        return '\n'.join(fixed_code)