Upload 4 files

README.md

@@ -1,13 +1,37 @@
----
-title: TraderApp
-emoji: 📚
-colorFrom: red
-colorTo: green
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
-short_description: Upload an chart image and receive tech analisis
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Trader Técnico Experto - Aplicación Streamlit
+
+Esta aplicación de Streamlit analiza gráficos de activos financieros y proporciona recomendaciones de trading a corto y largo plazo.
+
+## Características
+
+- Carga y visualización de imágenes de gráficos
+- Detección de tendencias (alcista, bajista, neutral)
+- Identificación de patrones de velas japonesas
+- Detección de niveles de soporte y resistencia
+- Generación de recomendaciones a corto y largo plazo
+- Visualización del análisis técnico con anotaciones
+
+## Cómo usar
+
+1. Sube una imagen de un gráfico de cualquier activo financiero
+2. La aplicación analizará automáticamente la tendencia, patrones y niveles clave
+3. Recibe recomendaciones de trading a corto y largo plazo
+
+## Instalación local
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Tecnologías utilizadas
+
+- Streamlit para la interfaz de usuario
+- OpenCV y Pillow para procesamiento de imágenes
+- Matplotlib para visualización
+- Scikit-learn para análisis de datos
+- Pandas y NumPy para manipulación de datos
+
+## Disclaimer
+
+Este análisis es generado automáticamente y tiene fines educativos. No constituye asesoramiento financiero. Realice su propia investigación antes de tomar decisiones de inversión.

Spacefile

@@ -0,0 +1,3 @@
+sdk: streamlit
+sdk_version: 1.44.1
+app_file: app.py

app.py

@@ -0,0 +1,339 @@
+import streamlit as st
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+import io
+import os
+from datetime import datetime
+import pandas as pd
+from sklearn.linear_model import LinearRegression
+
+# Configuración de la página
+st.set_page_config(
+    page_title="Análisis Técnico de Trading",
+    page_icon="📈",
+    layout="wide"
+)
+
+# Título y descripción
+st.title("Análisis Técnico de Trading")
+st.markdown("""
+Esta aplicación analiza gráficos de activos financieros y proporciona recomendaciones de trading.
+Sube una imagen de un gráfico y obtén un análisis técnico junto con recomendaciones a corto y largo plazo.
+""")
+
+# Función para cargar y procesar la imagen
+def load_and_process_image(uploaded_file):
+    if uploaded_file is not None:
+        # Leer la imagen
+        image = Image.open(uploaded_file)
+        img_array = np.array(image)
+        
+        # Convertir a escala de grises para procesamiento
+        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY) if len(img_array.shape) > 2 else img_array
+        
+        return image, img_array, gray
+    return None, None, None
+
+# Función para detectar tendencias en el gráfico
+def detect_trend(img_array, gray):
+    # Detectar bordes
+    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
+    
+    # Detectar líneas usando la transformada de Hough
+    lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=100, minLineLength=100, maxLineGap=10)
+    
+    # Analizar pendientes de las líneas para determinar tendencia
+    slopes = []
+    if lines is not None:
+        for line in lines:
+            x1, y1, x2, y2 = line[0]
+            if x2 != x1:  # Evitar división por cero
+                slope = (y2 - y1) / (x2 - x1)
+                slopes.append(slope)
+    
+    # Determinar tendencia basada en pendientes
+    if not slopes:
+        return "Neutral", 0
+    
+    avg_slope = np.mean(slopes)
+    
+    # En gráficos, y aumenta hacia abajo, por lo que pendiente negativa = tendencia alcista
+    if avg_slope < -0.1:
+        strength = min(abs(avg_slope) * 10, 10)
+        return "Alcista", strength
+    elif avg_slope > 0.1:
+        strength = min(abs(avg_slope) * 10, 10)
+        return "Bajista", strength
+    else:
+        return "Neutral", min(abs(avg_slope) * 20, 5)
+
+# Función para detectar patrones de velas
+def detect_candlestick_patterns(img_array):
+    # Simulación de detección de patrones
+    # En una implementación real, se utilizaría un modelo entrenado para reconocer patrones
+    
+    # Detectar colores predominantes (verde/rojo)
+    hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
+    
+    # Máscara para color verde (velas alcistas)
+    lower_green = np.array([40, 40, 40])
+    upper_green = np.array([80, 255, 255])
+    green_mask = cv2.inRange(hsv, lower_green, upper_green)
+    green_count = np.sum(green_mask > 0)
+    
+    # Máscara para color rojo (velas bajistas)
+    lower_red1 = np.array([0, 50, 50])
+    upper_red1 = np.array([10, 255, 255])
+    lower_red2 = np.array([170, 50, 50])
+    upper_red2 = np.array([180, 255, 255])
+    red_mask1 = cv2.inRange(hsv, lower_red1, upper_red1)
+    red_mask2 = cv2.inRange(hsv, lower_red2, upper_red2)
+    red_mask = red_mask1 + red_mask2
+    red_count = np.sum(red_mask > 0)
+    
+    patterns = []
+    
+    # Determinar patrones basados en colores predominantes
+    if green_count > red_count * 1.5:
+        patterns.append("Posible patrón de velas alcistas")
+        if np.random.random() > 0.5:  # Simulación
+            patterns.append("Posible Martillo Alcista")
+    elif red_count > green_count * 1.5:
+        patterns.append("Posible patrón de velas bajistas")
+        if np.random.random() > 0.5:  # Simulación
+            patterns.append("Posible Estrella Fugaz")
+    else:
+        patterns.append("Patrón de velas mixto o indeciso")
+        if np.random.random() > 0.7:  # Simulación
+            patterns.append("Posible Doji")
+    
+    return patterns
+
+# Función para detectar soportes y resistencias
+def detect_support_resistance(gray):
+    # Simulación de detección de soportes y resistencias
+    # En una implementación real, se utilizaría análisis de histograma o detección de líneas horizontales
+    
+    # Proyección horizontal (suma de píxeles por fila)
+    h_projection = np.sum(gray, axis=1)
+    
+    # Normalizar
+    h_projection = h_projection / np.max(h_projection)
+    
+    # Encontrar picos (posibles soportes/resistencias)
+    peaks = []
+    for i in range(1, len(h_projection) - 1):
+        if h_projection[i] > h_projection[i-1] and h_projection[i] > h_projection[i+1] and h_projection[i] > 0.7:
+            peaks.append((i, h_projection[i]))
+    
+    # Ordenar por intensidad
+    peaks.sort(key=lambda x: x[1], reverse=True)
+    
+    # Tomar los 3 picos más fuertes
+    top_peaks = peaks[:min(3, len(peaks))]
+    
+    # Convertir a niveles de soporte/resistencia
+    levels = []
+    height = gray.shape[0]
+    
+    for peak in top_peaks:
+        y_pos = peak[0]
+        # En gráficos, la parte superior es resistencia, la parte inferior es soporte
+        if y_pos < height / 2:
+            levels.append(("Resistencia", y_pos / height))
+        else:
+            levels.append(("Soporte", y_pos / height))
+    
+    return levels
+
+# Función para generar recomendaciones
+def generate_recommendations(trend, trend_strength, patterns, support_resistance):
+    recommendations = {
+        "corto_plazo": "",
+        "largo_plazo": "",
+        "niveles_clave": [],
+        "confianza_corto": 0,
+        "confianza_largo": 0
+    }
+    
+    # Recomendación a corto plazo basada en tendencia y patrones
+    if trend == "Alcista":
+        if trend_strength > 7:
+            recommendations["corto_plazo"] = "Comprar con stop loss ajustado"
+            recommendations["confianza_corto"] = min(trend_strength * 0.9, 9)
+        elif trend_strength > 4:
+            recommendations["corto_plazo"] = "Comprar en retrocesos"
+            recommendations["confianza_corto"] = trend_strength * 0.8
+        else:
+            recommendations["corto_plazo"] = "Comprar con precaución"
+            recommendations["confianza_corto"] = trend_strength * 0.7
+            
+    elif trend == "Bajista":
+        if trend_strength > 7:
+            recommendations["corto_plazo"] = "Vender o abrir cortos"
+            recommendations["confianza_corto"] = min(trend_strength * 0.9, 9)
+        elif trend_strength > 4:
+            recommendations["corto_plazo"] = "Vender rebotes"
+            recommendations["confianza_corto"] = trend_strength * 0.8
+        else:
+            recommendations["corto_plazo"] = "Mantener posiciones cortas existentes"
+            recommendations["confianza_corto"] = trend_strength * 0.7
+    else:
+        recommendations["corto_plazo"] = "Mantenerse al margen, mercado sin dirección clara"
+        recommendations["confianza_corto"] = trend_strength * 0.5
+    
+    # Ajustar recomendación basada en patrones de velas
+    for pattern in patterns:
+        if "alcista" in pattern.lower() and trend != "Bajista":
+            recommendations["corto_plazo"] += ". " + pattern + " refuerza señal de compra"
+            recommendations["confianza_corto"] = min(recommendations["confianza_corto"] + 1, 10)
+        elif "bajista" in pattern.lower() and trend != "Alcista":
+            recommendations["corto_plazo"] += ". " + pattern + " refuerza señal de venta"
+            recommendations["confianza_corto"] = min(recommendations["confianza_corto"] + 1, 10)
+        elif "doji" in pattern.lower():
+            recommendations["corto_plazo"] += ". " + pattern + " indica indecisión, considerar reducir exposición"
+            recommendations["confianza_corto"] = max(recommendations["confianza_corto"] - 1, 1)
+    
+    # Recomendación a largo plazo
+    if trend == "Alcista":
+        recommendations["largo_plazo"] = "Mantener posiciones largas con visión de medio/largo plazo"
+        recommendations["confianza_largo"] = min(trend_strength * 0.7, 8)
+    elif trend == "Bajista":
+        recommendations["largo_plazo"] = "Considerar estrategias de cobertura para el largo plazo"
+        recommendations["confianza_largo"] = min(trend_strength * 0.7, 8)
+    else:
+        recommendations["largo_plazo"] = "Acumular gradualmente en niveles de soporte clave"
+        recommendations["confianza_largo"] = 5
+    
+    # Añadir información de soportes y resistencias
+    for level_type, level_value in support_resistance:
+        if level_type == "Soporte":
+            recommendations["niveles_clave"].append(f"Soporte en nivel {level_value:.2f}")
+            if trend == "Alcista":
+                recommendations["largo_plazo"] += f". Considerar aumentar posición en soporte {level_value:.2f}"
+        else:  # Resistencia
+            recommendations["niveles_clave"].append(f"Resistencia en nivel {level_value:.2f}")
+            if trend == "Bajista":
+                recommendations["largo_plazo"] += f". Considerar reducir exposición en resistencia {level_value:.2f}"
+    
+    return recommendations
+
+# Función para visualizar el análisis
+def visualize_analysis(image, trend, patterns, support_resistance):
+    fig, ax = plt.subplots(figsize=(10, 6))
+    ax.imshow(image)
+    
+    # Añadir anotaciones
+    height, width = image.size[1], image.size[0]
+    
+    # Anotar tendencia
+    ax.text(width * 0.05, height * 0.1, f"Tendencia: {trend}", 
+            color='white', fontsize=12, bbox=dict(facecolor='black', alpha=0.7))
+    
+    # Anotar patrones
+    for i, pattern in enumerate(patterns):
+        ax.text(width * 0.05, height * (0.2 + i * 0.05), pattern, 
+                color='white', fontsize=10, bbox=dict(facecolor='blue', alpha=0.7))
+    
+    # Anotar soportes y resistencias
+    for level_type, level_value in support_resistance:
+        y_pos = int(level_value * height)
+        color = 'green' if level_type == "Soporte" else 'red'
+        ax.axhline(y=y_pos, color=color, linestyle='--', alpha=0.7)
+        ax.text(width * 0.8, y_pos, level_type, 
+                color='white', fontsize=10, bbox=dict(facecolor=color, alpha=0.7))
+    
+    plt.axis('off')
+    return fig
+
+# Interfaz principal
+uploaded_file = st.file_uploader("Sube una imagen de un gráfico", type=["jpg", "jpeg", "png"])
+
+if uploaded_file is not None:
+    # Mostrar imagen original
+    image, img_array, gray = load_and_process_image(uploaded_file)
+    
+    if image is not None:
+        st.image(image, caption="Gráfico subido", use_column_width=True)
+        
+        with st.spinner('Analizando gráfico...'):
+            # Detectar tendencia
+            trend, trend_strength = detect_trend(img_array, gray)
+            
+            # Detectar patrones de velas
+            patterns = detect_candlestick_patterns(img_array)
+            
+            # Detectar soportes y resistencias
+            support_resistance = detect_support_resistance(gray)
+            
+            # Generar recomendaciones
+            recommendations = generate_recommendations(trend, trend_strength, patterns, support_resistance)
+            
+            # Mostrar análisis
+            st.subheader("Análisis Técnico")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.markdown(f"**Tendencia detectada:** {trend}")
+                st.markdown(f"**Fuerza de la tendencia:** {trend_strength:.1f}/10")
+                
+                st.markdown("**Patrones identificados:**")
+                for pattern in patterns:
+                    st.markdown(f"- {pattern}")
+                
+                st.markdown("**Niveles clave:**")
+                for level in recommendations["niveles_clave"]:
+                    st.markdown(f"- {level}")
+            
+            with col2:
+                # Visualizar análisis
+                fig = visualize_analysis(image, trend, patterns, support_resistance)
+                st.pyplot(fig)
+            
+            # Mostrar recomendaciones
+            st.subheader("Recomendaciones de Trading")
+            
+            rec_col1, rec_col2 = st.columns(2)
+            
+            with rec_col1:
+                st.markdown("### Operación a Corto Plazo")
+                st.markdown(recommendations["corto_plazo"])
+                st.progress(float(recommendations["confianza_corto"]/10))
+                st.markdown(f"*Nivel de confianza: {recommendations['confianza_corto']:.1f}/10*")
+            
+            with rec_col2:
+                st.markdown("### Estrategia a Largo Plazo")
+                st.markdown(recommendations["largo_plazo"])
+                st.progress(float(recommendations["confianza_largo"]/10))
+                st.markdown(f"*Nivel de confianza: {recommendations['confianza_largo']:.1f}/10*")
+            
+            # Disclaimer
+            st.markdown("---")
+            st.markdown("""
+            **Disclaimer:** Este análisis es generado automáticamente y tiene fines educativos. 
+            No constituye asesoramiento financiero. Realice su propia investigación antes de tomar decisiones de inversión.
+            """)
+else:
+    # Mostrar ejemplo cuando no hay archivo subido
+    st.info("👆 Sube una imagen de un gráfico para comenzar el análisis")
+    
+    # Mostrar información de ejemplo
+    st.subheader("¿Cómo funciona?")
+    st.markdown("""
+    1. **Sube una imagen** de un gráfico de cualquier activo financiero
+    2. La aplicación **analiza automáticamente** la tendencia, patrones y niveles clave
+    3. Recibe **recomendaciones de trading** a corto y largo plazo
+    
+    La aplicación utiliza técnicas de procesamiento de imágenes y análisis técnico para identificar:
+    - Tendencias alcistas, bajistas o laterales
+    - Patrones de velas japonesas
+    - Niveles de soporte y resistencia
+    - Señales de compra o venta
+    """)
+
+# Información del pie de página
+st.markdown("---")
+st.markdown("Desarrollado con ❤️ usando Streamlit y técnicas de análisis de imágenes")

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+pillow
+opencv-python-headless
+matplotlib
+pandas
+numpy
+scikit-learn