Initial commit with clean codebase

.space

@@ -0,0 +1,4 @@
+title: Pattern Analysis API
+sdk: docker
+port: 7865
+entrypoint: python run.py

Docker

@@ -0,0 +1,15 @@
+FROM python:3.9-slim
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+EXPOSE 7865
+
+ENV PYTHONPATH=/code
+
+CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7865"]

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9-slim
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . /code
+
+EXPOSE 7865
+
+CMD ["python", "run.py"]

__init__.py

@@ -0,0 +1 @@
+from app import app

api-2.py

@@ -0,0 +1,66 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import requests
+import pandas as pd
+import numpy as np
+from pattern_analyzer import PatternAnalyzer
+from indicator_analyzer import IndicatorAnalyzer
+from chart_maker import ChartMaker
+from test_data import test_data
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/analyze/{symbol}")
+async def analyze_patterns(symbol: str, timeframe: str = "1D"):
+    try:
+        # Fetch OHLCV data
+        candle_response = requests.get(f"http://localhost:5000/fetch_candles?symbol={symbol}&timeframe={timeframe}")
+        ohlcv_data = candle_response.json()
+        
+        # Create DataFrame with correct column structure
+        df = pd.DataFrame(ohlcv_data)
+        df = df.rename(columns={'time': 'timestamp'})
+        
+        # Initialize analyzers
+        pattern_analyzer = PatternAnalyzer()
+        indicator_analyzer = IndicatorAnalyzer()
+        chart_maker = ChartMaker()
+        
+        # Get analysis results
+        patterns = pattern_analyzer.analyze_data(df)
+        indicators = indicator_analyzer.analyze_indicators(df)
+        pattern_charts = chart_maker.create_pattern_chart(df, patterns)
+        
+        return {
+            "patterns": patterns,
+            "indicators": indicators,
+            "charts": pattern_charts,
+            "ohlcv_data": ohlcv_data
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/")
+async def root():
+    return {
+        "status": "online",
+        "service": "Pattern Analysis API",
+        "endpoints": {
+            "analyze": "/analyze/{symbol}",
+            "docs": "/docs",
+            "health": "/health"
+        }
+    }
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)

api.py

@@ -0,0 +1,5 @@
+from app import app
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7865)

app.py

@@ -0,0 +1,100 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import requests
+import aiohttp
+import pandas as pd
+import numpy as np
+import asyncio
+import json
+from datetime import datetime
+from typing import Dict, List, Optional
+import gc
+
+# Import project modules
+from pattern_analyzer import PatternAnalyzer
+from indicator_analyzer import IndicatorAnalyzer
+from chart_maker import ChartMaker
+
+app = FastAPI(title="Pattern Analysis API")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global instances
+pattern_analyzer = PatternAnalyzer()
+indicator_analyzer = IndicatorAnalyzer()
+chart_maker = ChartMaker()
+
+async def analyze_stream(symbol: str, timeframe: str):
+    async def generate():
+        try:
+            yield json.dumps({"status": "fetching_data"}) + "\n"
+            
+            response = requests.get(
+                f"http://localhost:5000/fetch_candles",
+                params={"symbol": symbol, "timeframe": timeframe}
+            )
+            ohlcv_data = response.json()
+            
+            yield json.dumps({"status": "processing_data"}) + "\n"
+            
+            df = pd.DataFrame(ohlcv_data)
+            df.index = range(len(df))
+            df['time'] = pd.to_datetime(df['time'], unit='ms')
+            
+            required_columns = ['time', 'open', 'high', 'low', 'close', 'volume']
+            for col in required_columns:
+                if col not in df.columns:
+                    df[col] = 0
+                    
+            yield json.dumps({"status": "analyzing_patterns"}) + "\n"
+            patterns = pattern_analyzer.analyze_data(df)
+            
+            yield json.dumps({"status": "calculating_indicators"}) + "\n"
+            indicators = indicator_analyzer.analyze_indicators(df)
+            
+            yield json.dumps({"status": "generating_charts"}) + "\n"
+            pattern_charts = chart_maker.create_pattern_chart(df, patterns)
+            
+            final_response = {
+                "status": "complete",
+                "symbol": symbol,
+                "timeframe": timeframe,
+                "patterns": patterns,
+                "indicators": indicators,
+                "charts": pattern_charts,
+                "data": ohlcv_data
+            }
+            
+            yield json.dumps(final_response) + "\n"
+            
+        except Exception as e:
+            yield json.dumps({"status": "error", "detail": str(e)}) + "\n"
+
+    return StreamingResponse(generate(), media_type="application/x-ndjson")
+
+@app.get("/analyze/{symbol}")
+async def analyze_patterns(symbol: str, timeframe: str = "1D"):
+    return await analyze_stream(symbol, timeframe)
+
+@app.get("/")
+def read_root():
+    return {"message": "Pattern Analysis API is running"}
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy"}
+
+def start():
+    return app
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=7865, reload=True)

auto_chart_generator.py

@@ -0,0 +1,21 @@
+from pattern_analyzer import PatternAnalyzer
+from lightweight_charts import Chart
+
+class AutoChartGenerator:
+    def __init__(self):
+        self.analyzer = PatternAnalyzer()
+        
+    def generate_pattern_charts(self, ohlcv_data):
+        patterns = self.analyzer.analyze_data(ohlcv_data)
+        
+        charts = []
+        for pattern in patterns:
+            chart = Chart()
+            chart.candlestick(ohlcv_data)
+            chart.draw_pattern(
+                pattern_type=pattern['type'],
+                coordinates=pattern['coordinates']
+            )
+            charts.append(chart)
+            
+        return charts

chart_maker.py

@@ -0,0 +1,69 @@
+from lightweight_charts import Chart
+import pandas as pd
+import numpy as np
+
+class ChartMaker:
+    def __init__(self):
+        self.patterns = [
+            'channel', 'triangle', 'head_shoulders',
+            'double_top', 'double_bottom', 'wedge',
+            'flag', 'pennant'
+        ]
+        
+        self.indicators = [
+            'ema', 'sma', 'rsi', 'macd', 
+            'bollinger', 'ichimoku', 'pivot_points'
+        ]
+    
+    def create_pattern_chart(self, ohlcv_data, patterns):
+        chart = Chart()
+        
+        # Format OHLCV data for charting
+        chart_data = []
+        for index, row in ohlcv_data.iterrows():
+            data_point = {
+                'time': row['time'] if isinstance(row['time'], int) else int(row['time'].timestamp() * 1000),
+                'open': float(row['open']),
+                'high': float(row['high']),
+                'low': float(row['low']),
+                'close': float(row['close']),
+                'volume': float(row['volume'])
+            }
+            chart_data.append(data_point)
+        
+        # Create main price series
+        chart.create_series('price', 'Candlestick', chart_data)
+        
+        # Add volume series
+        volume_data = [{
+            'time': d['time'],
+            'value': d['volume']
+        } for d in chart_data]
+        chart.create_series('volume', 'Histogram', volume_data)
+        
+        # Add patterns as overlays
+        for pattern in patterns:
+            if pattern['type'] in self.patterns and 'coordinates' in pattern:
+                chart.create_series(
+                    f"pattern_{pattern['type']}", 
+                    'Line', 
+                    pattern['coordinates'],
+                    {
+                        'color': 'rgba(76, 175, 80, 0.5)',
+                        'lineWidth': 2,
+                        'title': f"{pattern['type']} ({pattern.get('confidence', 0):.2f})"
+                    }
+                )
+        
+        return chart
+    
+    
+    def generate_all_variations(self, ohlcv_data):
+        charts = []
+        for pattern in self.patterns:
+            pattern_chart = self.create_pattern_chart(ohlcv_data, [{'type': pattern}])
+            charts.append({
+                'type': pattern,
+                'chart': pattern_chart
+            })
+        return charts

indicator_analyzer.py

@@ -0,0 +1,66 @@
+import ollama
+import numpy as np
+import pandas as pd
+from lightweight_charts import Chart
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+class IndicatorAnalyzer:
+    def __init__(self):
+        self.model = AutoModelForCausalLM.from_pretrained("tmm-dev/codellama-pattern-analysis")
+        self.tokenizer = AutoTokenizer.from_pretrained("tmm-dev/codellama-pattern-analysis")
+        
+    def analyze_indicators(self, ohlcv_data):
+        indicator_prompt = f"""
+        Analyze this OHLCV data and calculate optimal indicators:
+        {ohlcv_data.to_json(orient='records')}
+        Calculate and return:
+        - Moving Averages (EMA, SMA with optimal periods)
+        - Oscillators (RSI, Stochastic, MACD)
+        - Volatility (Bollinger Bands, ATR)
+        - Volume indicators
+        - Custom combinations of indicators
+        
+        Return the analysis in JSON format with exact values and coordinates.
+        """
+        
+        response = self.client.chat(
+            model='codellama:latest',
+            messages=[
+                {
+                    'role': 'system',
+                    'content': 'You are a technical analysis indicator calculation model.'
+                },
+                {
+                    'role': 'user',
+                    'content': indicator_prompt
+                }
+            ]
+        )
+        
+        return self.parse_indicator_analysis(response['message']['content'])
+        
+    def parse_indicator_analysis(self, analysis):
+        try:
+            # Convert string response to structured data
+            if isinstance(analysis, str):
+                # Extract JSON if embedded in text
+                json_start = analysis.find('{')
+                json_end = analysis.rfind('}') + 1
+                if json_start >= 0 and json_end > 0:
+                    analysis = analysis[json_start:json_end]
+                    
+            indicators = {
+                'moving_averages': {},
+                'oscillators': {},
+                'volatility': {},
+                'volume': {},
+                'custom': {}
+            }
+            
+            # Add any custom parsing logic here
+            
+            return indicators
+            
+        except Exception as e:
+            print(f"Error parsing indicator analysis: {str(e)}")
+            return {}

indicator_chart_generator.py

@@ -0,0 +1,22 @@
+from indicator_analyzer import IndicatorAnalyzer
+from lightweight_charts import Chart
+
+class AutoIndicatorGenerator:
+    def __init__(self):
+        self.analyzer = IndicatorAnalyzer()
+        
+    def generate_indicator_charts(self, ohlcv_data):
+        indicators = self.analyzer.analyze_indicators(ohlcv_data)
+        
+        charts = []
+        for indicator in indicators:
+            chart = Chart()
+            chart.candlestick(ohlcv_data)
+            chart.add_indicator(
+                type=indicator['type'],
+                values=indicator['values'],
+                parameters=indicator['parameters']
+            )
+            charts.append(chart)
+            
+        return charts

main.py

@@ -0,0 +1,85 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import requests
+import pandas as pd
+import numpy as np
+import asyncio
+import json
+from datetime import datetime
+from typing import Dict, List, Optional
+import gc
+
+from pattern_analyzer import PatternAnalyzer
+from indicator_analyzer import IndicatorAnalyzer
+from chart_maker import ChartMaker
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+pattern_analyzer = PatternAnalyzer()
+indicator_analyzer = IndicatorAnalyzer()
+chart_maker = ChartMaker()
+
+async def analyze_stream(symbol: str, timeframe: str):
+    async def generate():
+        try:
+            yield json.dumps({"status": "fetching_data"}) + "\n"
+            
+            response = requests.get(
+                f"http://localhost:5000/fetch_candles",
+                params={"symbol": symbol, "timeframe": timeframe}
+            )
+            ohlcv_data = response.json()
+            
+            yield json.dumps({"status": "processing_data"}) + "\n"
+            
+            df = pd.DataFrame(ohlcv_data)
+            df.index = range(len(df))
+            df['time'] = pd.to_datetime(df['time'], unit='ms')
+            
+            required_columns = ['time', 'open', 'high', 'low', 'close', 'volume']
+            for col in required_columns:
+                if col not in df.columns:
+                    df[col] = 0
+                    
+            yield json.dumps({"status": "analyzing_patterns"}) + "\n"
+            patterns = pattern_analyzer.analyze_data(df)
+            
+            yield json.dumps({"status": "calculating_indicators"}) + "\n"
+            indicators = indicator_analyzer.analyze_indicators(df)
+            
+            yield json.dumps({"status": "generating_charts"}) + "\n"
+            pattern_charts = chart_maker.create_pattern_chart(df, patterns)
+            
+            final_response = {
+                "status": "complete",
+                "symbol": symbol,
+                "timeframe": timeframe,
+                "patterns": patterns,
+                "indicators": indicators,
+                "charts": pattern_charts,
+                "data": ohlcv_data
+            }
+            
+            yield json.dumps(final_response) + "\n"
+            
+        except Exception as e:
+            yield json.dumps({"status": "error", "detail": str(e)}) + "\n"
+
+    return StreamingResponse(generate(), media_type="application/x-ndjson")
+
+@app.get("/analyze/{symbol}")
+async def analyze_patterns(symbol: str, timeframe: str = "1D"):
+    return await analyze_stream(symbol, timeframe)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

pattern_analyzer.py

@@ -0,0 +1,69 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import numpy as np
+import pandas as pd
+import json
+from pattern_logic import PatternLogic
+
+class PatternAnalyzer:
+    def __init__(self):
+        self.model = AutoModelForCausalLM.from_pretrained("tmm-dev/codellama-pattern-analysis")
+        self.tokenizer = AutoTokenizer.from_pretrained("tmm-dev/codellama-pattern-analysis")
+        self.basic_patterns = {
+            'channel': {'min_points': 4, 'confidence_threshold': 0.7},
+            'triangle': {'min_points': 3, 'confidence_threshold': 0.75},
+            'support': {'min_touches': 2, 'confidence_threshold': 0.8},
+            'resistance': {'min_touches': 2, 'confidence_threshold': 0.8},
+            'double_top': {'max_deviation': 0.02, 'confidence_threshold': 0.85},
+            'double_bottom': {'max_deviation': 0.02, 'confidence_threshold': 0.85}
+        }
+        self.pattern_logic = PatternLogic()
+
+    def analyze_data(self, ohlcv_data):
+        data_prompt = f"""TASK: Identify high-confidence technical patterns only. 
+        Minimum confidence threshold: 0.8
+        Required pattern criteria:
+        1. Channel: Must have at least 3 touching points
+        2. Triangle: Must have clear convergence point
+        3. Support: Minimum 3 price bounces
+        4. Resistance: Minimum 3 price rejections
+
+        INPUT DATA:
+        {ohlcv_data.to_json(orient='records')}
+
+        Return ONLY high-confidence patterns (>0.8) in JSON format with exact price coordinates."""
+
+        inputs = self.tokenizer(data_prompt, return_tensors="pt")
+        outputs = self.model.generate(**inputs, max_length=1000)
+        analysis = self.tokenizer.decode(outputs[0])
+
+        return self.parse_analysis(analysis)
+        
+    def parse_analysis(self, analysis_text):
+        try:
+            json_start = analysis_text.find('{')
+            json_end = analysis_text.rfind('}') + 1
+            json_str = analysis_text[json_start:json_end]
+            
+            analysis_data = json.loads(json_str)
+            patterns = []
+            
+            for pattern in analysis_data.get('patterns', []):
+                pattern_type = pattern.get('type')
+                
+                if pattern_type in self.basic_patterns:
+                    threshold = self.basic_patterns[pattern_type]['confidence_threshold']
+                    if pattern.get('confidence', 0) >= threshold:
+                        patterns.append({
+                            'type': pattern_type,
+                            'coordinates': pattern.get('coordinates', []),
+                            'confidence': pattern.get('confidence'),
+                            'metadata': {
+                                'rules': self.basic_patterns[pattern_type],
+                                'timestamp': pd.Timestamp.now().isoformat()
+                            }
+                        })
+            
+            return patterns
+            
+        except json.JSONDecodeError:
+            return []

pattern_logic.py

@@ -0,0 +1,103 @@
+import numpy as np
+import pandas as pd
+from test_data import test_data
+from typing import List, Dict, Optional, Union
+
+class PatternLogic:
+    def __init__(self):
+        self.patterns = {
+            'channel': {'min_points': 4, 'confidence_threshold': 0.7},
+            'triangle': {'min_points': 3, 'confidence_threshold': 0.75},
+            'support': {'min_touches': 2, 'confidence_threshold': 0.8},
+            'resistance': {'min_touches': 2, 'confidence_threshold': 0.8},
+            'double_top': {'max_deviation': 0.02, 'confidence_threshold': 0.85},
+            'double_bottom': {'max_deviation': 0.02, 'confidence_threshold': 0.85}
+        }
+        self.test_data = test_data
+    
+    def detect_channels(self, data: pd.DataFrame) -> Dict[str, Union[str, List[List[float]], float]]:
+        days = len(data)
+        base_price = 100
+        price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+        base_prices = base_price * (1 + price_changes)
+        
+        high_prices = base_prices * (1 + np.random.normal(0.01, 0.008, days))
+        low_prices = base_prices * (1 + np.random.normal(-0.01, 0.008, days))
+        timestamps = np.arange(days)
+        
+        upper_channel: List[List[float]] = []
+        lower_channel: List[List[float]] = []
+        
+        for i in range(days):
+            upper_channel.append([float(timestamps[i]), float(high_prices[i])])
+            lower_channel.append([float(timestamps[i]), float(low_prices[i])])
+        
+        return {
+            'type': 'channel',
+            'upper': upper_channel,
+            'lower': lower_channel,
+            'confidence': 0.85
+        }
+    
+    def find_support_resistance(self, data: pd.DataFrame) -> List[Dict[str, Union[str, List[List[float]], float]]]:
+        days = len(data)
+        base_price = 100
+        price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+        close_prices = base_price * (1 + price_changes) * (1 + np.random.normal(0, 0.005, days))
+        timestamps = np.arange(days)
+        levels: List[Dict] = []
+        
+        for i in range(1, days-1):
+            current_price = float(close_prices[i])
+            prev_price = float(close_prices[i-1])
+            next_price = float(close_prices[i+1])
+            
+            if current_price > prev_price and current_price > next_price:
+                levels.append({
+                    'type': 'resistance',
+                    'coordinates': [[float(timestamps[i]), current_price]],
+                    'confidence': 0.8
+                })
+            if current_price < prev_price and current_price < next_price:
+                levels.append({
+                    'type': 'support',
+                    'coordinates': [[float(timestamps[i]), current_price]],
+                    'confidence': 0.8
+                })
+        
+        return levels
+    
+    def detect_triangles(self, data: pd.DataFrame) -> Optional[Dict[str, Union[str, List[List[float]], float]]]:
+        days = len(data)
+        base_price = 100
+        price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+        base_prices = base_price * (1 + price_changes)
+        
+        high_prices = base_prices * (1 + np.random.normal(0.01, 0.008, days))
+        low_prices = base_prices * (1 + np.random.normal(-0.01, 0.008, days))
+        timestamps = np.arange(days)
+        
+        first_high = float(high_prices[0])
+        last_high = float(high_prices[-1])
+        first_low = float(low_prices[0])
+        last_low = float(low_prices[-1])
+        
+        if last_high < first_high and last_low > first_low:
+            return {
+                'type': 'triangle',
+                'coordinates': [
+                    [float(timestamps[0]), first_high],
+                    [float(timestamps[-1]), last_high],
+                    [float(timestamps[0]), first_low],
+                    [float(timestamps[-1]), last_low]
+                ],
+                'confidence': 0.75
+            }
+        return None
+
+    def validate_patterns(self, patterns: List[Dict]) -> List[Dict]:
+        validated = []
+        for pattern in patterns:
+            if pattern.get('confidence', 0) >= 0.8:
+                validated.append(pattern)
+        return validated

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+numpy==1.26.1
+pandas==2.1.1
+requests==2.31.0
+python-multipart==0.0.6
+python-dotenv==1.0.0
+transformers==4.35.0
+torch==2.1.0
+accelerate==0.24.0
+lightweight-charts==2.0.0
+gunicorn==20.1.0

run.py

@@ -0,0 +1,6 @@
+from fastapi import FastAPI
+from app import app
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=7865, reload=True)

test_charts.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+from auto_chart_generator import AutoChartGenerator
+from indicator_chart_generator import AutoIndicatorGenerator
+
+# Generate 150 days of OHLCV data
+np.random.seed(42)
+days = 150
+base_price = 100
+
+price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+prices = base_price * (1 + price_changes)
+
+test_data = {
+    'open': prices * (1 + np.random.normal(0, 0.005, days)),
+    'high': prices * (1 + np.random.normal(0.01, 0.008, days)),
+    'low': prices * (1 + np.random.normal(-0.01, 0.008, days)),
+    'close': prices * (1 + np.random.normal(0, 0.005, days)),
+    'volume': np.random.normal(1000000, 200000, days)
+}
+
+df = pd.DataFrame(test_data)
+df['high'] = df[['open', 'high', 'close']].max(axis=1)
+df['low'] = df[['open', 'low', 'close']].min(axis=1)
+
+# Test pattern charts
+pattern_gen = AutoChartGenerator()
+pattern_charts = pattern_gen.generate_pattern_charts(df)
+print("Generated Pattern Charts:", len(pattern_charts))
+
+# Test indicator charts
+indicator_gen = AutoIndicatorGenerator()
+indicator_charts = indicator_gen.generate_indicator_charts(df)
+print("Generated Indicator Charts:", len(indicator_charts))

test_data.py

@@ -0,0 +1,23 @@
+import numpy as np
+import pandas as pd
+
+# Generate 150 days test data
+days = 150
+base_price = 100
+
+# Generate price changes with realistic volatility
+price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+base_prices = base_price * (1 + price_changes)
+
+# Create DataFrame with all OHLCV components
+test_data = pd.DataFrame({
+    'open': base_prices * (1 + np.random.normal(0, 0.005, days)),  # Opening prices
+    'high': base_prices * (1 + np.random.normal(0.01, 0.008, days)),  # Day's high prices
+    'low': base_prices * (1 + np.random.normal(-0.01, 0.008, days)),  # Day's low prices
+    'close': base_prices * (1 + np.random.normal(0, 0.005, days)),  # Closing prices
+    'volume': np.random.normal(1000000, 200000, days).astype(int)  # Daily volume
+})
+
+# Ensure high is always highest and low is always lowest
+test_data['high'] = test_data[['open', 'high', 'close']].max(axis=1)
+test_data['low'] = test_data[['open', 'low', 'close']].min(axis=1)

test_imports.py

@@ -0,0 +1,29 @@
+try:
+    import gradio as gr
+    print("✅ Gradio imported successfully")
+except:
+    print("❌ Gradio import failed")
+
+try:
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    print("✅ Transformers imported successfully")
+except:
+    print("❌ Transformers import failed")
+
+try:
+    from lightweight_charts import Chart
+    print("✅ Lightweight Charts imported successfully")
+except:
+    print("❌ Lightweight Charts import failed")
+
+try:
+    from fastapi import FastAPI
+    print("✅ FastAPI imported successfully")
+except:
+    print("❌ FastAPI import failed")
+
+try:
+    from datasets import Dataset, load_dataset
+    print("✅ Datasets imported successfully")
+except:
+    print("❌ Datasets import failed")

test_indicators.py

@@ -0,0 +1,28 @@
+import numpy as np
+import pandas as pd
+from indicator_analyzer import IndicatorAnalyzer
+
+# Generate 150 days of OHLCV data
+np.random.seed(42)
+days = 150
+base_price = 100
+
+price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+prices = base_price * (1 + price_changes)
+
+test_data = {
+    'open': prices * (1 + np.random.normal(0, 0.005, days)),
+    'high': prices * (1 + np.random.normal(0.01, 0.008, days)),
+    'low': prices * (1 + np.random.normal(-0.01, 0.008, days)),
+    'close': prices * (1 + np.random.normal(0, 0.005, days)),
+    'volume': np.random.normal(1000000, 200000, days)
+}
+
+df = pd.DataFrame(test_data)
+df['high'] = df[['open', 'high', 'close']].max(axis=1)
+df['low'] = df[['open', 'low', 'close']].min(axis=1)
+
+# Test indicator analysis
+analyzer = IndicatorAnalyzer()
+indicators = analyzer.analyze_indicators(df)
+print("Generated Indicators:", indicators)

test_model.py

@@ -0,0 +1,34 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import numpy as np
+import pandas as pd
+
+# Load model
+model = AutoModelForCausalLM.from_pretrained("codellama/CodeLlama-7b-hf")
+tokenizer = AutoTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
+
+# Create test data
+days = 150
+base_price = 100
+price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+prices = base_price * (1 + price_changes)
+
+test_data = pd.DataFrame({
+    'open': prices * (1 + np.random.normal(0, 0.005, days)),
+    'high': prices * (1 + np.random.normal(0.01, 0.008, days)),
+    'low': prices * (1 + np.random.normal(-0.01, 0.008, days)),
+    'close': prices * (1 + np.random.normal(0, 0.005, days)),
+    'volume': np.random.normal(1000000, 200000, days)
+})
+
+# Test pattern detection
+prompt = f"""
+Analyze this OHLCV data and detect patterns:
+{test_data.head().to_string()}
+Return: Pattern type and coordinates
+"""
+
+inputs = tokenizer(prompt, return_tensors="pt")
+outputs = model.generate(**inputs, max_length=500)
+result = tokenizer.decode(outputs[0])
+
+print("Model Output:", result)

test_patterns.py

@@ -0,0 +1,32 @@
+import numpy as np
+import pandas as pd
+from pattern_analyzer import PatternAnalyzer
+
+# Generate 150 days of realistic OHLCV data
+np.random.seed(42)  # For reproducibility
+days = 150
+base_price = 100
+
+# Create price movements with trends and volatility
+price_changes = np.random.normal(0.001, 0.02, days).cumsum()
+prices = base_price * (1 + price_changes)
+
+test_data = {
+    'open': prices * (1 + np.random.normal(0, 0.005, days)),
+    'high': prices * (1 + np.random.normal(0.01, 0.008, days)),
+    'low': prices * (1 + np.random.normal(-0.01, 0.008, days)),
+    'close': prices * (1 + np.random.normal(0, 0.005, days)),
+    'volume': np.random.normal(1000000, 200000, days)
+}
+
+# Convert to pandas DataFrame for better handling
+df = pd.DataFrame(test_data)
+
+# Ensure high is highest and low is lowest for each day
+df['high'] = df[['open', 'high', 'close']].max(axis=1)
+df['low'] = df[['open', 'low', 'close']].min(axis=1)
+
+# Test pattern detection
+analyzer = PatternAnalyzer()
+patterns = analyzer.analyze_data(df)
+print("Detected Patterns:", patterns)

train.py

@@ -0,0 +1,29 @@
+from transformers import Trainer, TrainingArguments
+from datasets import Dataset
+
+def prepare_training_data():
+    # Training data structure
+    return {
+        'pattern_type': ['channel', 'triangle'],
+        'chart_code': ['// Channel code', '// Triangle code']
+    }
+
+def train_model():
+    # Create dataset
+    data = prepare_training_data()
+    dataset = Dataset.from_dict(data)
+    
+    training_args = TrainingArguments(
+        output_dir="./results",
+        num_train_epochs=3,
+        per_device_train_batch_size=8,
+        save_steps=500,
+    )
+    
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset,
+    )
+    
+    trainer.train()

trigger_handler.py

@@ -0,0 +1,21 @@
+from chart_maker import ChartMaker
+from fastapi import FastAPI
+
+
+class TriggerHandler:
+    def __init__(self):
+        self.chart_maker = ChartMaker()
+    
+    async def handle_chart_trigger(self, trigger_data):
+        # Extract chart image and OHLCV data
+        chart_image = trigger_data['image']
+        ohlcv_data = trigger_data['ohlcv']
+        
+        # Generate pattern charts
+        pattern_charts = self.chart_maker.generate_all_variations(ohlcv_data)
+        
+        # Return generated charts through API
+        return {
+            'pattern_charts': pattern_charts,
+            'timestamp': trigger_data['timestamp']
+        }