Update auth/auth_manager.py

auth/auth_manager.py

@@ -1,296 +1,204 @@
-def show_chart_analysis_tab(claude_service, analysis_service):
-    """Display chart analysis functionality"""
-    # Get user expertise level
-    expertise_level = create_expertise_selector()
-    
-    # Create sidebar and get inputs
-    upload_option, uploaded_files, patterns, indicators, comparison_type = create_sidebar()
-    
-    # Main content area
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        st.title("📈 Stock Chart Analysis Assistant")
+# auth/auth_manager.py
+
+import streamlit as st
+import json
+import os
+from pathlib import Path
+import hashlib
+from datetime import datetime, timedelta
+
+class AuthManager:
+    def __init__(self):
+        """Initialize AuthManager with storage in HuggingFace's /data directory"""
+        # Use HuggingFace's /data directory for persistent storage
+        self.storage_path = Path("/data/users")
+        self.ensure_storage()
         
-        if upload_option == "Ask Question":
-            question = st.text_input(
-                "What would you like to know?",
-                key="main_question_input"
-            )
+        # Initialize demo user if not exists
+        self._init_demo_user()
         
-        # Main analysis section
-        if uploaded_files:
-            # Store all uploaded images
-            st.session_state.current_images = [file.getvalue() for file in uploaded_files]
+        # Initialize session state for auth
+        if 'auth' not in st.session_state:
+            st.session_state.auth = {
+                'authenticated': False,
+                'user': None,
+                'login_time': None
+            }
+
+    def ensure_storage(self):
+        """Ensure storage directories exist and are writable"""
+        try:
+            # Create main storage directory
+            self.storage_path.mkdir(parents=True, exist_ok=True)
             
-        analyze_clicked = show_analysis_section(uploaded_files)
+            # Test write permissions
+            test_file = self.storage_path / ".write_test"
+            test_file.touch()
+            test_file.unlink()
+        except Exception as e:
+            st.error(f"Failed to access storage: {str(e)}")
+            raise RuntimeError("Storage is not accessible")
+
+    def _init_demo_user(self):
+        """Initialize demo Synaptyx user"""
+        demo_user = {
+            "username": "synaptyx",
+            "password_hash": self._hash_password("demo"),
+            "display_name": "Synaptyx Demo",
+            "storage_path": "/data/users/synaptyx",
+            "created_at": datetime.now().isoformat(),
+            "last_login": None,
+            "settings": {
+                "expertise_level": "Intermediate",
+                "theme": "default",
+                "notifications_enabled": True
+            }
+        }
         
-        # Store analysis results in session state
-        if 'analysis_results' not in st.session_state:
-            st.session_state.analysis_results = []
+        user_file = self.storage_path / "synaptyx.json"
+        if not user_file.exists():
+            # Create user storage directories
+            user_storage = Path(demo_user["storage_path"])
+            for dir_name in ["chats", "images", "context", "exports"]:
+                (user_storage / dir_name).mkdir(parents=True, exist_ok=True)
             
-        if analyze_clicked:
-            if not uploaded_files:
-                st.warning("Please upload at least one chart.")
-            else:
-                with st.spinner("Analyzing charts..."):
-                    results = analysis_service.analyze_multiple_charts(
-                        st.session_state.current_images,
-                        patterns,
-                        indicators,
-                        comparison_type,
-                        expertise_level
-                    )
-                    
-                    if results:
-                        st.session_state.current_analysis = results[-1]['analysis']
-                        st.session_state.chat_history.extend(results)
-                        st.session_state.analysis_results = results
+            # Save user data
+            with open(user_file, "w") as f:
+                json.dump(demo_user, f, indent=4)
 
-        # Display analysis results from session state
-        if st.session_state.analysis_results:
-            results = st.session_state.analysis_results
-            
-            # First show comparative analysis if it exists
-            for result in results:
-                if result.get('analysis_type') != 'Individual':
-                    with st.container():
-                        st.subheader(f"{result['analysis_type']} Results")
-                        st.markdown(result['analysis'])
-                        
-                        # Add follow-up section immediately after analysis
-                        follow_up = show_follow_up_section(f"comparative_followup")
-                        if follow_up:
-                            with st.spinner("Processing follow-up..."):
-                                response = analysis_service.handle_follow_up_question(
-                                    follow_up,
-                                    result['analysis'],
-                                    st.session_state.current_images
-                                )
-                                if response:
-                                    st.session_state.chat_history.append(response)
-                                    st.markdown(response['analysis'])
+    def _hash_password(self, password):
+        """Hash password using SHA-256 with salt"""
+        salt = "synaptyx_salt"  # In production, use a proper salt management system
+        salted = password + salt
+        return hashlib.sha256(salted.encode()).hexdigest()
+
+    def login(self, username, password):
+        """Authenticate user and set up session"""
+        try:
+            user_file = self.storage_path / f"{username}.json"
+            if not user_file.exists():
+                return False
+                
+            with open(user_file, "r") as f:
+                user_data = json.load(f)
+                
+            if user_data["password_hash"] == self._hash_password(password):
+                # Update last login
+                user_data["last_login"] = datetime.now().isoformat()
+                with open(user_file, "w") as f:
+                    json.dump(user_data, f, indent=4)
+                
+                # Update session state
+                st.session_state.auth = {
+                    'authenticated': True,
+                    'user': user_data,
+                    'login_time': datetime.now().isoformat()
+                }
+                return True
+                
+            return False
+        except Exception as e:
+            st.error(f"Login error: {str(e)}")
+            return False
+
+    def is_authenticated(self):
+        """Check if user is authenticated and session is valid"""
+        if not st.session_state.auth.get('authenticated'):
+            return False
             
-            # Then show individual analyses
-            individual_analyses = [r for r in results if r.get('analysis_type') == 'Individual']
-            for idx, result in enumerate(individual_analyses):
-                with st.container():
-                    st.subheader(f"Analysis Results - Chart {idx + 1}")
-                    st.markdown(result['analysis'])
-                    
-                    # Add follow-up section for each analysis
-                    container_key = f"individual_followup_{idx}"
-                    follow_up = show_follow_up_section(container_key)
-                    if follow_up:
-                        with st.spinner("Processing follow-up..."):
-                            response = analysis_service.handle_follow_up_question(
-                                follow_up,
-                                result['analysis'],
-                                st.session_state.current_images[idx] if idx < len(st.session_state.current_images) else None
-                            )
-                            if response:
-                                st.session_state.chat_history.append(response)
-                                st.markdown(response['analysis'])
+        # Check session age (optional)
+        if st.session_state.auth.get('login_time'):
+            login_time = datetime.fromisoformat(st.session_state.auth['login_time'])
+            session_age = datetime.now() - login_time
             
-            # Risk warning at the bottom
-            st.warning(
-                "⚠️ This analysis is AI-generated and for informational purposes only. "
-                "Do not make trading decisions solely based on this information."
-            )
-    
-    with col2:
-        # Chat history
-        show_chat_history(st.session_state.chat_history)
+            # Session timeout after 12 hours
+            if session_age > timedelta(hours=12):
+                self.logout()
+                return False
         
-        # Save options
-        save_name = show_save_options()
-        if save_name and st.session_state.chat_history:
-            filename = save_chat_history(
-                st.session_state.chat_history,
-                st.session_state.current_images[0] if st.session_state.current_images else None,
-                f"{save_name}.json" if save_name else None
-            )
-            if filename:
-                st.success(f"Chat saved as {filename}")
-            else:
-                st.info("Chat saved to session state")# app.py
-
-import streamlit as st
-from services.claude_service import ClaudeService
-from services.chart_analysis import ChartAnalysisService
-from ui.components import (
-    create_sidebar,
-    show_analysis_section,
-    show_chat_history,
-    show_follow_up_section,
-    show_save_options,
-    create_expertise_selector
-)
-from utils.file_handlers import save_chat_history
-from utils.learning_module import LearningModule
+        return True
 
-def init_session_state():
-    """Initialize session state variables"""
-    if 'chat_history' not in st.session_state:
-        st.session_state.chat_history = []
-    if 'current_image' not in st.session_state:
-        st.session_state.current_image = None
-    if 'current_analysis' not in st.session_state:
-        st.session_state.current_analysis = None
-    if 'current_images' not in st.session_state:
-        st.session_state.current_images = []
-    if 'conversation_context' not in st.session_state:
-        st.session_state.conversation_context = []
-    if 'current_conversation_id' not in st.session_state:
-        st.session_state.current_conversation_id = None
+    def get_user_storage_paths(self):
+        """Get user's storage paths"""
+        if not self.is_authenticated():
+            return None
+            
+        base_path = Path(st.session_state.auth['user']["storage_path"])
+        return {
+            "chats": base_path / "chats",
+            "images": base_path / "images",
+            "context": base_path / "context",
+            "exports": base_path / "exports"
+        }
 
-def show_chart_analysis_tab(claude_service, analysis_service):
-    """Display chart analysis functionality"""
-    # Get user expertise level
-    expertise_level = create_expertise_selector()
-    
-    # Create sidebar and get inputs
-    upload_option, uploaded_files, patterns, indicators, comparison_type = create_sidebar()
-    
-    # Main content area
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        st.title("📈 Stock Chart Analysis Assistant")
-        
-        if upload_option == "Ask Question":
-            question = st.text_input(
-                "What would you like to know?",
-                key="main_question_input"
-            )
-        
-        # Main analysis section
-        if uploaded_files:
-            # Store all uploaded images
-            st.session_state.current_images = [file.getvalue() for file in uploaded_files]
+    def get_user_settings(self):
+        """Get user's settings"""
+        if not self.is_authenticated():
+            return None
             
-        analyze_clicked = show_analysis_section(uploaded_files)
-        
-        if analyze_clicked:
-            if not uploaded_files:
-                st.warning("Please upload at least one chart.")
-            else:
-                with st.spinner("Analyzing charts..."):
-                    results = analysis_service.analyze_multiple_charts(
-                        st.session_state.current_images,
-                        patterns,
-                        indicators,
-                        comparison_type,
-                        expertise_level
-                    )
-                    
-                    if results:
-                        # Store current analysis
-                        st.session_state.current_analysis = results[-1]['analysis']  # Latest analysis
-                        st.session_state.chat_history.extend(results)
-                        
-                        # Display analyses
-                        # First show comparative analysis if it exists
-                        for result in results:
-                            if result.get('analysis_type') != 'Individual':
-                                st.subheader(f"{result['analysis_type']} Results")
-                                st.write(result['analysis'])
-                                # Add follow-up section immediately
-                                follow_up = show_follow_up_section(f"comparative_followup")
-                                if follow_up:
-                                    with st.spinner("Processing follow-up..."):
-                                        response = analysis_service.handle_follow_up_question(
-                                            follow_up,
-                                            result['analysis'],
-                                            st.session_state.current_images
-                                        )
-                                        if response:
-                                            st.session_state.chat_history.append(response)
-                                            st.write(response['analysis'])
-                        
-                        # Then show individual analyses
-                        individual_analyses = [r for r in results if r.get('analysis_type') == 'Individual']
-                        for idx, result in enumerate(individual_analyses):
-                            st.subheader(f"Analysis Results - Chart {idx + 1}")
-                            st.write(result['analysis'])
-                            # Add follow-up section for each individual analysis
-                            follow_up = show_follow_up_section(f"individual_followup_{idx}")
-                            if follow_up:
-                                with st.spinner("Processing follow-up..."):
-                                    response = analysis_service.handle_follow_up_question(
-                                        follow_up,
-                                        result['analysis'],
-                                        st.session_state.current_images[idx] if idx < len(st.session_state.current_images) else None
-                                    )
-                                    if response:
-                                        st.session_state.chat_history.append(response)
-                                        st.write(response['analysis'])
-                        
-                        # Risk warning
-                        st.warning(
-                            "⚠️ This analysis is AI-generated and for informational purposes only. "
-                            "Do not make trading decisions solely based on this information."
-                        )
-    
-    with col2:
-        # Chat history
-        show_chat_history(st.session_state.chat_history)
-        
-        # Save options
-        save_name = show_save_options()
-        if save_name and st.session_state.chat_history:
-            filename = save_chat_history(
-                st.session_state.chat_history,
-                st.session_state.current_images[0] if st.session_state.current_images else None,
-                f"{save_name}.json" if save_name else None
-            )
-            if filename:
-                st.success(f"Chat saved as {filename}")
-            else:
-                st.info("Chat saved to session state")
+        return st.session_state.auth['user'].get('settings', {})
 
-def show_learning_tab(learning_module):
-    """Display learning center functionality"""
-    st.title("📚 Trading Learning Center")
-    
-    # Create tabs for different learning options
-    learn_tab1, learn_tab2 = st.tabs(["Structured Courses", "Custom Learning"])
-    
-    with learn_tab1:
-        st.header("Learn Trading Step by Step")
-        learning_module.display_course_selection()
-        
-    with learn_tab2:
-        st.header("Ask Any Trading Question")
-        learning_module.display_custom_learning()
+    def update_user_settings(self, settings):
+        """Update user's settings"""
+        if not self.is_authenticated():
+            return False
+            
+        try:
+            user_file = self.storage_path / f"{st.session_state.auth['user']['username']}.json"
+            with open(user_file, "r") as f:
+                user_data = json.load(f)
+            
+            user_data['settings'].update(settings)
+            
+            with open(user_file, "w") as f:
+                json.dump(user_data, f, indent=4)
+            
+            # Update session state
+            st.session_state.auth['user'] = user_data
+            return True
+        except Exception as e:
+            st.error(f"Failed to update settings: {str(e)}")
+            return False
 
-def main():
-    st.set_page_config(
-        page_title="Stock Chart Assistant",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-    
-    # Initialize services
-    try:
-        claude_service = ClaudeService()
-        analysis_service = ChartAnalysisService(claude_service)
-        learning_module = LearningModule(claude_service)
-    except ValueError as e:
-        st.error(str(e))
-        return
-    
-    # Initialize session state
-    init_session_state()
-    
-    # Main application tabs
-    tab1, tab2 = st.tabs(["Chart Analysis", "Learning Center"])
-    
-    with tab1:
-        show_chart_analysis_tab(claude_service, analysis_service)
-        
-    with tab2:
-        show_learning_tab(learning_module)
+    def logout(self):
+        """Log out user and clear session"""
+        if 'auth' in st.session_state:
+            st.session_state.auth = {
+                'authenticated': False,
+                'user': None,
+                'login_time': None
+            }
 
-if __name__ == "__main__":
-    main()
+    def get_user_stats(self):
+        """Get user's usage statistics"""
+        if not self.is_authenticated():
+            return None
+            
+        try:
+            stats = {
+                'total_analyses': 0,
+                'total_chats': 0,
+                'storage_used': 0
+            }
+            
+            paths = self.get_user_storage_paths()
+            if not paths:
+                return stats
+                
+            # Count analyses and chats
+            stats['total_chats'] = len(list(paths['chats'].glob('*.json')))
+            
+            # Calculate storage used
+            for path in paths.values():
+                if path.exists():
+                    stats['storage_used'] += sum(f.stat().st_size 
+                                               for f in path.rglob('*') 
+                                               if f.is_file())
+            
+            # Convert to MB
+            stats['storage_used'] = round(stats['storage_used'] / (1024 * 1024), 2)
+            
+            return stats
+        except Exception as e:
+            st.error(f"Failed to get user stats: {str(e)}")
+            return None