Delete pattern-analysis

pattern-analysis/Docker

@@ -1,13 +0,0 @@
-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"]

pattern-analysis/__init__.py

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

pattern-analysis/api-2.py

@@ -1,66 +0,0 @@
-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)

pattern-analysis/api.py

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

pattern-analysis/app.py

@@ -1,100 +0,0 @@
-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)

pattern-analysis/auto_chart_generator.py

@@ -1,21 +0,0 @@
-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

pattern-analysis/chart_maker.py

@@ -1,69 +0,0 @@
-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

pattern-analysis/indicator_analyzer.py

@@ -1,66 +0,0 @@
-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 {}

pattern-analysis/main.py

@@ -1,85 +0,0 @@
-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-analysis/pattern_analyzer.py

@@ -1,69 +0,0 @@
-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-analysis/pattern_logic.py

@@ -1,103 +0,0 @@
-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

pattern-analysis/requirements.txt

@@ -1,12 +0,0 @@
-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

pattern-analysis/run.py

@@ -1,6 +0,0 @@
-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)

pattern-analysis/test_patterns.py

@@ -1,32 +0,0 @@
-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)