Upload 13 files

app.py

@@ -1,32 +1,47 @@
 import gradio as gr
-from src.model.vision_model import ChartVisionModel
-import ollama
+from src.analysis.chart_processor import ChartProcessor
+from src.analysis.pattern_generator import PatternGenerator
+from src.analysis.indicator_generator import IndicatorGenerator
+from src.analysis.chart_analyzer import ChartAnalyzer
+from src.data.market_data import MarketData
 
-def analyze_chart(image):
-    client = ollama.Client()
+def analyze_full_chart(chart_image, symbol):
+    market_data = MarketData()
+    historical_data = market_data.fetch_ohlcv(symbol)
     
-    system_prompt = """Analyze this technical chart and provide:
-    1. Pattern Recognition (Support/Resistance, Trends)
-    2. Technical Indicators Analysis
-    3. Price Action Analysis
-    4. Volume Analysis
-    5. Future Price Predictions
-    Format the response in clear sections."""
+    pattern_gen = PatternGenerator()
+    pattern_images = pattern_gen.generate_all_patterns(chart_image, historical_data)
     
-    response = client.generate(
-        model="llama3.2-vision:latest",
-        prompt=system_prompt,
-        images=[image]
+    indicator_gen = IndicatorGenerator()
+    indicator_charts = indicator_gen.generate_all_indicators(historical_data)
+    
+    analyzer = ChartAnalyzer()
+    analysis_results = analyzer.analyze_full(
+        chart_image=chart_image,
+        pattern_images=pattern_images,
+        indicator_charts=indicator_charts,
+        historical_data=historical_data
     )
     
-    return response
+    return {
+        'pattern_analysis': analysis_results.patterns,
+        'indicator_analysis': analysis_results.indicators,
+        'predictions': analysis_results.predictions,
+        'interactive_charts': indicator_charts
+    }
 
 interface = gr.Interface(
-    fn=analyze_chart,
-    inputs=gr.Image(type="pil"),
-    outputs=gr.Textbox(label="Analysis Results"),
-    title="Technical Chart Analysis",
-    description="Upload a chart image for comprehensive technical analysis"
+    fn=analyze_full_chart,
+    inputs=[
+        gr.Image(type="pil", label="Chart Image"),
+        gr.Textbox(label="Symbol")
+    ],
+    outputs=[
+        gr.Gallery(label="Pattern Overlays"),
+        gr.Gallery(label="Indicator Charts"),
+        gr.JSON(label="Analysis Results"),
+        gr.Plot(label="Interactive Indicators")
+    ]
 )
 
-interface.launch()
+interface.launch()

chart_analyzer.py

@@ -0,0 +1,29 @@
+import ollama
+from src.model.vision_model import ChartVisionModel
+
+class ChartAnalyzer:
+    def __init__(self):
+        self.vision_model = ChartVisionModel()
+        self.client = ollama.Client()
+    
+    def analyze_full(self, chart_image, pattern_images, indicator_charts, historical_data):
+        vision_analysis = self.vision_model.analyze_chart(chart_image)
+        
+        system_prompt = """Analyze this technical chart with all patterns and indicators:
+        1. Pattern Analysis (300+ patterns)
+        2. Indicator Analysis
+        3. Current Chart Analysis
+        4. Movement Predictions
+        Provide detailed analysis for each component."""
+        
+        analysis = self.client.generate(
+            model="llama3.2-vision:latest",
+            prompt=system_prompt,
+            images=[chart_image] + pattern_images
+        )
+        
+        return {
+            'patterns': self._analyze_patterns(pattern_images),
+            'indicators': self._analyze_indicators(indicator_charts),
+            'predictions': self._generate_predictions(analysis)
+        }

generator_endpoint.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+from transformers import pipeline
+
+app = FastAPI()
+chart_generator = pipeline("text-generation", model="tmmdev/chart-generator")
+
+@app.post("/generate")
+async def generate_charts(data: dict):
+    charts = chart_generator(data)
+    return {
+        "interactive_charts": charts.charts,
+        "pattern_images": charts.patterns
+    }

indicator_generator.py

@@ -0,0 +1,36 @@
+import ollama
+from lightweight_charts import Chart
+
+class IndicatorGenerator:
+    def __init__(self):
+        self.client = ollama.Client()
+        self.code_model = "codellama:latest"
+        self.indicators = [
+            'rsi', 'macd', 'bollinger_bands', 'moving_averages',
+            'stochastic', 'atr', 'volume_profile'
+        ]
+    
+    def generate_all_indicators(self, historical_data):
+        indicator_charts = []
+        for indicator in self.indicators:
+            # Generate code for indicator using CodeLlama
+            code_prompt = f"Generate Lightweight Charts code for {indicator} indicator with proper styling and configuration"
+            code_response = self.client.generate(
+                model=self.code_model,
+                prompt=code_prompt
+            )
+            
+            # Create chart using generated code
+            chart = Chart()
+            chart.set(code_response)  # Applies the generated configuration
+            chart.add_data(historical_data)
+            
+            indicator_charts.append(chart)
+        
+        return indicator_charts
+
+    def _create_indicator_chart(self, data, indicator_type):
+        chart = Chart()
+        # Specific indicator configurations using Lightweight Charts
+        chart.add_indicator(indicator_type, data)
+        return chart

model_uploader.py

@@ -0,0 +1,23 @@
+from huggingface_hub import HfApi, login
+import ollama
+
+def export_and_upload_models():
+    api = HfApi()
+    login()
+    
+    # Export Ollama models
+    models = {
+        "llama3.2-vision": "tmmdev/chart-vision-analyzer",
+        "codellama": "tmmdev/chart-generator"
+    }
+    
+    for model_name, repo_id in models.items():
+        # Export model from Ollama
+        model_path = ollama.export(model_name)
+        
+        # Upload to HF
+        api.upload_folder(
+            folder_path=model_path,
+            repo_id=repo_id,
+            repo_type="model"
+        )

package-lock.json

@@ -0,0 +1,27 @@
+{
+  "name": "ai",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "lightweight-charts": "^5.0.1"
+      }
+    },
+    "node_modules/fancy-canvas": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fancy-canvas/-/fancy-canvas-2.1.0.tgz",
+      "integrity": "sha512-nifxXJ95JNLFR2NgRV4/MxVP45G9909wJTEKz5fg/TZS20JJZA6hfgRVh/bC9bwl2zBtBNcYPjiBE4njQHVBwQ==",
+      "license": "MIT"
+    },
+    "node_modules/lightweight-charts": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/lightweight-charts/-/lightweight-charts-5.0.1.tgz",
+      "integrity": "sha512-JjqI+Uoxuw/XESn6BeBp+o8kxa+CgvkbM7edhoarJ5KRjY1INqi0Hvahn88Q8Ou5sfckHbTGGKrM2lQQYsuH5A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "fancy-canvas": "2.1.0"
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "lightweight-charts": "^5.0.1"
+  }
+}

pattern_generator.py

@@ -0,0 +1,32 @@
+import ollama
+from lightweight_charts import Chart
+
+class PatternGenerator:
+    def __init__(self):
+        self.client = ollama.Client()
+        self.code_model = "codellama:latest"
+        self.patterns = [
+            'head_and_shoulders', 'double_top', 'double_bottom',
+            'triangle', 'channel', 'fibonacci', 'wedge', 'flag',
+            'pennant', 'cup_and_handle', 'rounding_bottom'
+            # Will expand to 300+ patterns
+        ]
+    
+    def generate_all_patterns(self, chart_image, historical_data):
+        pattern_charts = []
+        for pattern in self.patterns:
+            # Generate pattern drawing code using CodeLlama
+            code_prompt = f"Generate Lightweight Charts code to draw {pattern} pattern with proper styling and technical analysis markers"
+            code_response = self.client.generate(
+                model=self.code_model,
+                prompt=code_prompt
+            )
+            
+            # Create chart with pattern overlay
+            chart = Chart()
+            chart.set(code_response)
+            chart.add_data(historical_data)
+            
+            pattern_charts.append(chart)
+        
+        return pattern_charts

requirements.txt

@@ -5,3 +5,19 @@ python-ollama>=0.1.0
 Pillow>=10.0.0
 huggingface-hub>=0.19.0
 python-dotenv>=1.0.0
+fastapi
+uvicorn
+gradio
+huggingface-hub
+transformers
+torch
+lightweight-charts
+pandas
+numpy
+requests
+python-multipart
+ollama
+python-dotenv
+plotly
+opencv-python
+pillow

update_space.py

@@ -0,0 +1,19 @@
+from huggingface_hub import HfApi, login
+from dotenv import load_dotenv
+import os
+
+def update_space_repo():
+    load_dotenv()
+    api = HfApi()
+    login()  # Will use HF_TOKEN from environment
+    
+    api.upload_folder(
+        folder_path=".",
+        repo_id="tmmdev/chart-analyzer",
+        repo_type="space"
+    )
+    
+    print("✨ Space updated successfully!")
+
+if __name__ == "__main__":
+    update_space_repo()

vision_endpoint.py

@@ -0,0 +1,10 @@
+from fastapi import FastAPI, File
+from transformers import pipeline
+
+app = FastAPI()
+vision_model = pipeline("image-analysis", model="tmmdev/chart-vision-analyzer")
+
+@app.post("/analyze")
+async def analyze_chart(image: File):
+    analysis = vision_model(image)
+    return {"analysis": analysis}

vision_model.py

@@ -0,0 +1,16 @@
+import ollama
+from PIL import Image
+
+class ChartVisionModel:
+    def __init__(self):
+        self.client = ollama.Client()
+        self.model = "llava:34b"  # Using LLaVA for vision analysis
+    
+    def analyze_chart(self, image):
+        response = self.client.generate(
+            model=self.model,
+            prompt="Analyze this technical chart in detail",
+            images=[image]
+        )
+        return response
+