Upload 5 files

.gitignore

@@ -0,0 +1,173 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# Streamlit specific
+.streamlit/secrets.toml
+
+# AWS credentials
+.aws/
+aws-credentials.json
+
+# Test files
+test_*.py
+*_test.py
+tests/
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+
+# OS specific
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Uploaded files for testing
+uploads/
+test_files/

.streamlit/secrets.toml

@@ -0,0 +1,5 @@
+[aws]
+AWS_ACCESS_KEY_ID = "AKIA6IYSQD72LEVVXE6J"
+AWS_SECRET_ACCESS_KEY = "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"
+AWS_DEFAULT_REGION = "us-east-1"
+

README.md

@@ -1,20 +1,274 @@
----
-title: Jose Test Deploy
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: desc
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# 🏦 Analizador de Comprobantes Bancarios
+
+## 📋 Descripción del Proyecto
+
+Esta aplicación web desarrollada en **Streamlit** permite extraer información específica de comprobantes bancarios utilizando **Amazon Textract**, un servicio de AWS especializado en extracción de texto y análisis de documentos. La aplicación puede procesar imágenes de comprobantes y extraer automáticamente datos como montos, números de operación, fechas, y más información relevante.
+
+## 🎯 Funcionalidades Principales
+
+- ✅ Extracción automática de texto de comprobantes bancarios
+- ✅ Análisis inteligente de formularios y tablas
+- ✅ Reconocimiento de patrones específicos bancarios
+- ✅ Exportación de datos extraídos en formato JSON
+- ✅ Interfaz web intuitiva con vista previa de documentos
+
+## 🛠️ Tecnologías Utilizadas
+
+### Librerías Principales
+
+- **Streamlit**: Framework para crear aplicaciones web interactivas
+- **boto3**: SDK oficial de AWS para Python (interacción con servicios AWS)
+- **PIL (Pillow)**: Procesamiento y manipulación de imágenes
+- **pandas**: Manipulación y análisis de datos estructurados
+- **re**: Expresiones regulares para extracción de patrones
+
+### Servicios AWS
+
+- **Amazon Textract**: Servicio de extracción de texto y análisis de documentos
+
+## 📁 Estructura del Código
+
+### 1. Clase `BankingReceiptAnalyzer`
+
+**Propósito**: Gestiona la comunicación con AWS Textract para el análisis de documentos.
+
+#### Método `__init__(self)`
+```python
+def __init__(self):
+```
+- **Función**: Constructor que inicializa la conexión con AWS Textract
+- **Consumo de librería**: Utiliza `boto3.client()` para crear cliente de Textract
+- **Configuración**: Lee credenciales desde `st.secrets` (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION)
+- **Manejo de errores**: Valida credenciales y maneja excepciones de conexión
+
+#### Método `analyze_document_with_forms(self, image_bytes)`
+```python
+def analyze_document_with_forms(self, image_bytes: bytes) -> Dict[str, Any]:
+```
+- **Función**: Análisis avanzado de documentos con reconocimiento de formularios y tablas
+- **Consumo AWS**: Utiliza `textract.analyze_document()` con características:
+  - `FORMS`: Detecta pares clave-valor en formularios
+  - `TABLES`: Reconoce estructuras tabulares
+- **Parámetros**: Recibe bytes de la imagen del documento
+- **Retorno**: Diccionario con bloques de texto estructurados o mensaje de error
+
+#### Método `extract_text_simple(self, image_bytes)`
+```python
+def extract_text_simple(self, image_bytes: bytes) -> Dict[str, Any]:
+```
+- **Función**: Extracción básica de texto línea por línea
+- **Consumo AWS**: Utiliza `textract.detect_document_text()` (método más simple)
+- **Procesamiento**: Filtra bloques de tipo 'LINE' para obtener texto legible
+- **Uso**: Ideal para documentos con texto simple sin estructura compleja
+
+### 2. Clase `BankingDataExtractor`
+
+**Propósito**: Procesa el texto extraído y identifica campos específicos bancarios usando patrones.
+
+#### Método `extract_banking_fields(text)`
+```python
+@staticmethod
+def extract_banking_fields(text: str) -> Dict[str, str]:
+```
+- **Función**: Extrae información bancaria específica usando expresiones regulares
+- **Consumo de librería**: Utiliza `re.search()` para patrones regex
+- **Campos detectables**:
+  - 💰 Importe enviado (S/ XXX.XX)
+  - 🏦 Entidad destino (nombre del banco)
+  - 💳 Comisión (S/ X.XX)
+  - 📊 ITF (Impuesto a las Transacciones Financieras)
+  - 🔢 Número de operación
+  - 📝 Tipo de operación
+  - 📅 Fecha y hora
+  - ✅ Estado de operación
+
+**Patrones de Búsqueda Ejemplo**:
+```python
+'importe_enviado': [
+    r'Importe enviado\s*S/\s*(\d+\.?\d*)',
+    r'S/\s*(\d+\.?\d*)',
+    r'Monto\s*S/\s*(\d+\.?\d*)'
+]
+```
+
+#### Método `_extract_account_numbers(text, fields)`
+```python
+@staticmethod
+def _extract_account_numbers(text: str, fields: Dict[str, str]) -> None:
+```
+- **Función**: Identifica números de cuenta origen y destino
+- **Patrones**: Busca formatos como "•1234", "Cuenta 123456789"
+- **Lógica**: Asigna primera cuenta como origen y segunda como destino
+
+#### Método `_extract_bank_names(text, fields)`
+```python
+@staticmethod
+def _extract_bank_names(text: str, fields: Dict[str, str]) -> None:
+```
+- **Función**: Detecta nombres de bancos peruanos comunes
+- **Bancos soportados**: BBVA, Plin, BCP, Interbank, Scotiabank, BanBif
+- **Método**: Búsqueda case-insensitive en el texto
+
+### 3. Función `display_extracted_banking_data(fields)`
+
+**Propósito**: Presenta los datos extraídos en una interfaz visual organizada.
+
+- **Consumo Streamlit**: Utiliza `st.metric()`, `st.dataframe()`, `st.columns()`
+- **Funcionalidades**:
+  - Métricas destacadas (importe, entidad, estado)
+  - Tabla detallada con todos los campos
+  - Indicadores de estado (detectado/no detectado)
+  - Botón de descarga en formato JSON
+- **Exportación**: Genera archivo JSON con timestamp y estadísticas de completitud
+
+### 4. Función `process_banking_receipt(uploaded_file, analyzer)`
+
+**Propósito**: Orquesta el proceso completo de análisis de un comprobante.
+
+- **Consumo PIL**: Utiliza `Image.open()` para mostrar vista previa
+- **Funcionalidades**:
+  - Vista previa del documento subido
+  - Dos métodos de análisis (Tabs):
+    - Análisis avanzado con formularios
+    - Extracción simple de texto
+  - Procesamiento de bytes del archivo
+  - Manejo de errores y estados de carga
+
+### 5. Función `main()`
+
+**Propósito**: Función principal que construye la interfaz de usuario completa.
+
+- **Consumo Streamlit**: Utiliza múltiples componentes:
+  - `st.title()`, `st.markdown()`: Títulos y contenido
+  - `st.sidebar`: Panel lateral informativo
+  - `st.file_uploader()`: Subida de archivos
+  - `st.columns()`: Layout en columnas
+- **Validaciones**: Verifica credenciales AWS antes de continuar
+- **Tipos de archivo**: Soporta JPG, PNG, PDF
+
+## FUNCIONAMIENTO
+
+
+## 🧠 **Dos "servicios" o capas distintas en el proceso**
+
+### 🔹 1. **OCR con IA** → *Textract (`extract_text_simple`)*
+
+* Es el **servicio de reconocimiento de texto (OCR)** de [AWS Textract](w).
+* Detecta el **texto visual** en una imagen escaneada (como un comprobante bancario).
+* **No interpreta** lo que ese texto significa, solo lo reconoce y lo devuelve como líneas o palabras.
+* Es como un escáner con **visión artificial inteligente**, que ve:
+
+  ```
+  "Importe enviado S/ 1250.00"
+  ```
+
+---
+
+### 🔹 2. **Servicio tipo “tag” semántico** → *`BankingDataExtractor`*
+
+* Es un **servicio personalizado**, hecho por ti (o el desarrollador).
+* Usa expresiones regulares para **“etiquetar” o clasificar** partes del texto como:
+
+  * `importe_enviado`, `fecha`, `comisión`, etc.
+* Es como un **motor de reglas semánticas** que dice:
+
+  >  `Importe enviado S/ X`, eso es el campo `importe_enviado`.”
+
+---
+
+## 🧪 Definicion:
+
+> AWS Textract es como un lector que **lee** el contenido de una carta (OCR),
+> `BankingDataExtractor` es un asistente que **resalta lo importante** con marcadores: el nombre del remitente, la fecha, el asunto, etc.
+
+---
+
+## 🧩 Diagrama:
+
+```
+🖼️ Imagen JPG/PDF
+     │
+     ▼
+🧠 AWS Textract (OCR IA)
+     └──▶ Texto plano
+              │
+              ▼
+🧾 BankingDataExtractor (Regex/tagger)
+              └──▶ Datos estructurados clave-valor
+```
+
+---
+
+## ✅ Conclusión:
+
+> Se usan 2 servicios: uno (Textract) es como un **OCR con inteligencia artificial** que extrae el texto visible, y el otro (el extractor con regex) **etiqueta o clasifica semánticamente** ese texto para obtener información útil y estructurada.
+
+
+
+## 🔧 Configuración y Uso
+
+### 1. Configuración de AWS
+
+**Archivo**: `secrets.toml` (Streamlit)
+```toml
+[aws]
+AWS_ACCESS_KEY_ID = "tu_access_key"
+AWS_SECRET_ACCESS_KEY = "tu_secret_key"
+AWS_DEFAULT_REGION = "us-east-1"
+```
+
+### 2. Instalación de Dependencias
+
+```bash
+pip install streamlit boto3 pillow pandas
+```
+
+### 3. Ejecución
+
+```bash
+streamlit run app.py
+```
+
+## 📊 Flujo de Trabajo
+
+1. **Carga de Documento**: Usuario sube imagen del comprobante
+2. **Procesamiento AWS**: Textract extrae texto y estructura
+3. **Análisis de Patrones**: Regex identifica campos bancarios específicos
+4. **Visualización**: Streamlit muestra datos extraídos
+5. **Exportación**: Descarga opcional en JSON
+
+## 🎯 Casos de Uso
+
+- ✅ Automatización de contabilidad empresarial
+- ✅ Reconciliación bancaria automatizada
+- ✅ Digitalización de comprobantes físicos
+- ✅ Auditorías y reportes financieros
+- ✅ Integración con sistemas ERP
+
+## ⚠️ Consideraciones Importantes
+
+### Limitaciones de AWS Textract
+- **Costo**: Servicio pagado por documento procesado
+- **Calidad**: Requiere imágenes claras y bien iluminadas
+- **Idioma**: Optimizado para texto en español/inglés
+
+### Seguridad
+- Credenciales AWS deben mantenerse seguras
+- Los documentos se procesan temporalmente en AWS
+- No se almacenan datos permanentemente
+
+## 🚀 Mejoras Futuras
+
+- 🔄 Procesamiento por lotes (múltiples comprobantes)
+- 🤖 Machine Learning personalizado para patrones específicos
+- 📱 Versión móvil optimizada
+- 🔐 Autenticación de usuarios
+- 📈 Dashboard de estadísticas
+
+## 📞 Soporte
+
+Para consultas técnicas o mejoras al código, contactar al desarrollador: [@JoseJeampierJaraSalas1997](https://github.com/JoseJeampierJaraSalas1997)
+
+---
+
+**Nota**: Este proyecto utiliza Amazon Textract, no Amazon Rekognition. Textract está especializado en extracción de texto y análisis de documentos, mientras que Rekognition se enfoca en reconocimiento de imágenes, caras y objetos.

app.py

@@ -0,0 +1,442 @@
+import streamlit as st
+import boto3
+from botocore.exceptions import ClientError, NoCredentialsError
+import json
+from PIL import Image
+import io
+import base64
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import re
+from datetime import datetime
+
+# Configuración de la página
+st.set_page_config(
+    page_title="Analizador de Comprobantes Bancarios",
+    page_icon="🏦",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+class BankingReceiptAnalyzer:
+    """Clase para analizar comprobantes bancarios usando AWS Textract"""
+    
+    def __init__(self):
+        """Inicializa el cliente de AWS Textract"""
+        try:
+            # Cargar credenciales desde secrets.toml
+            aws_access_key = st.secrets["aws"]["AWS_ACCESS_KEY_ID"]
+            aws_secret_key = st.secrets["aws"]["AWS_SECRET_ACCESS_KEY"]
+            aws_region = st.secrets["aws"]["AWS_DEFAULT_REGION"]
+            
+            # Inicializar cliente AWS Textract
+            self.textract = boto3.client(
+                'textract',
+                aws_access_key_id=aws_access_key,
+                aws_secret_access_key=aws_secret_key,
+                region_name=aws_region
+            )
+            
+            self.credentials_valid = True
+            
+        except KeyError as e:
+            st.error(f"❌ Credencial AWS faltante: {e}")
+            self.credentials_valid = False
+        except Exception as e:
+            st.error(f"❌ Error al inicializar AWS: {str(e)}")
+            self.credentials_valid = False
+    
+    def analyze_document_with_forms(self, image_bytes: bytes) -> Dict[str, Any]:
+        """Analiza un documento usando Textract con análisis de formularios"""
+        try:
+            response = self.textract.analyze_document(
+                Document={'Bytes': image_bytes},
+                FeatureTypes=['FORMS', 'TABLES']
+            )
+            return {"success": True, "blocks": response['Blocks']}
+        except ClientError as e:
+            return {"success": False, "error": f"Error de AWS: {e.response['Error']['Message']}"}
+        except Exception as e:
+            return {"success": False, "error": f"Error inesperado: {str(e)}"}
+    
+    def extract_text_simple(self, image_bytes: bytes) -> Dict[str, Any]:
+        """Extrae texto simple del documento"""
+        try:
+            response = self.textract.detect_document_text(
+                Document={'Bytes': image_bytes}
+            )
+            
+            # Extraer texto línea por línea
+            text_blocks = []
+            for block in response['Blocks']:
+                if block['BlockType'] == 'LINE':
+                    text_blocks.append(block['Text'])
+            
+            return {
+                "success": True, 
+                "text": '\n'.join(text_blocks),
+                "blocks": response['Blocks']
+            }
+        except ClientError as e:
+            return {"success": False, "error": f"Error de AWS: {e.response['Error']['Message']}"}
+        except Exception as e:
+            return {"success": False, "error": f"Error inesperado: {str(e)}"}
+
+class BankingDataExtractor:
+    """Clase para extraer información específica de comprobantes bancarios"""
+    
+    @staticmethod
+    def extract_banking_fields(text: str) -> Dict[str, str]:
+        """
+        Extrae campos específicos del texto del comprobante bancario
+        usando expresiones regulares y patrones
+        """
+        fields = {
+            'importe_enviado': '',
+            'entidad_destino': '',
+            'comision': '',
+            'itf': '',
+            'numero_operacion': '',
+            'tipo_operacion': '',
+            'fecha': '',
+            'cuenta_origen': '',
+            'cuenta_destino': '',
+            'estado_operacion': ''
+        }
+        
+        # Patrones de búsqueda
+        patterns = {
+            'importe_enviado': [
+                r'Importe enviado\s*S/\s*(\d+\.?\d*)',
+                r'S/\s*(\d+\.?\d*)',
+                r'Monto\s*S/\s*(\d+\.?\d*)',
+                r'Importe\s*S/\s*(\d+\.?\d*)'
+            ],
+            'entidad_destino': [
+                r'Entidad destino\s*([^\n]+)',
+                r'Destino\s*([^\n]+)',
+                r'Banco destino\s*([^\n]+)'
+            ],
+            'comision': [
+                r'Comisión\s*S/\s*(\d+\.?\d*)',
+                r'Comision\s*S/\s*(\d+\.?\d*)'
+            ],
+            'itf': [
+                r'ITF\s*S/\s*(\d+\.?\d*)'
+            ],
+            'numero_operacion': [
+                r'Número de operación\s*(\d+)',
+                r'Numero de operacion\s*(\d+)',
+                r'Operación\s*(\d+)',
+                r'Nro\.\s*operación\s*(\d+)'
+            ],
+            'tipo_operacion': [
+                r'Tipo de operación\s*([^\n]+)',
+                r'Tipo de operacion\s*([^\n]+)',
+                r'Operación\s*([^\n]+)'
+            ],
+            'fecha': [
+                r'(\d{1,2}\s+\w+\s+\d{4},?\s+\d{1,2}:\d{2}\s*h?)',
+                r'(\d{1,2}/\d{1,2}/\d{4}\s+\d{1,2}:\d{2})',
+                r'(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2})'
+            ],
+            'estado_operacion': [
+                r'(Operación exitosa)',
+                r'(Operacion exitosa)',
+                r'(Exitosa)',
+                r'(Completada)',
+                r'(Aprobada)'
+            ]
+        }
+        
+        # Buscar cada patrón en el texto
+        for field, pattern_list in patterns.items():
+            for pattern in pattern_list:
+                match = re.search(pattern, text, re.IGNORECASE)
+                if match:
+                    fields[field] = match.group(1).strip()
+                    break
+        
+        # Búsquedas adicionales específicas
+        BankingDataExtractor._extract_account_numbers(text, fields)
+        BankingDataExtractor._extract_bank_names(text, fields)
+        
+        return fields
+    
+    @staticmethod
+    def _extract_account_numbers(text: str, fields: Dict[str, str]) -> None:
+        """Extrae números de cuenta del texto"""
+        # Buscar patrones de cuentas
+        account_patterns = [
+            r'•(\d{4})',
+            r'Cuenta\s*(\d+)',
+            r'Cta\.\s*(\d+)'
+        ]
+        
+        accounts = []
+        for pattern in account_patterns:
+            matches = re.findall(pattern, text)
+            accounts.extend(matches)
+        
+        if len(accounts) >= 2:
+            fields['cuenta_origen'] = accounts[0]
+            fields['cuenta_destino'] = accounts[1]
+        elif len(accounts) == 1:
+            fields['cuenta_origen'] = accounts[0]
+    
+    @staticmethod
+    def _extract_bank_names(text: str, fields: Dict[str, str]) -> None:
+        """Extrae nombres de bancos del texto"""
+        bank_names = ['BBVA', 'Plin', 'BCP', 'Interbank', 'Scotiabank', 'BanBif']
+        
+        for bank in bank_names:
+            if bank.lower() in text.lower():
+                if not fields['entidad_destino']:
+                    fields['entidad_destino'] = bank
+                break
+
+def display_extracted_banking_data(fields: Dict[str, str]) -> None:
+    """Muestra los datos extraídos del comprobante bancario de forma estructurada"""
+    st.subheader("🏦 Información Extraída del Comprobante")
+    
+    # Crear métricas principales
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        if fields['importe_enviado']:
+            st.metric(
+                label="💰 Importe Enviado",
+                value=f"S/ {fields['importe_enviado']}" if fields['importe_enviado'] else "No detectado"
+            )
+    
+    with col2:
+        if fields['entidad_destino']:
+            st.metric(
+                label="🏦 Entidad Destino",
+                value=fields['entidad_destino'] or "No detectado"
+            )
+    
+    with col3:
+        if fields['estado_operacion']:
+            st.metric(
+                label="✅ Estado",
+                value=fields['estado_operacion'] or "No detectado"
+            )
+        st.subheader("📋 Detalle Completo")
+    
+    data_rows = []
+    field_labels = {
+        'importe_enviado': '💰 Importe Enviado',
+        'entidad_destino': '🏦 Entidad Destino',
+        'comision': '💳 Comisión',
+        'itf': '📊 ITF',
+        'numero_operacion': '🔢 Número de Operación',
+        'tipo_operacion': '📝 Tipo de Operación',
+        'fecha': '📅 Fecha y Hora',
+        'cuenta_origen': '📤 Cuenta Origen',
+        'cuenta_destino': '📥 Cuenta Destino',
+        'estado_operacion': '✅ Estado Operación'
+    }
+    
+    for field, label in field_labels.items():
+        value = fields.get(field, '')
+        status = "✅ Detectado" if value else "❌ No detectado"
+        data_rows.append({
+            'Campo': label,
+            'Valor': value or 'No encontrado',
+            'Estado': status
+        })
+    
+    df = pd.DataFrame(data_rows)
+    
+    # Mostrar tabla con colores
+    st.dataframe(
+        df,
+        use_container_width=True,
+        hide_index=True,
+        column_config={
+            "Campo": st.column_config.TextColumn("Campo", width="medium"),
+            "Valor": st.column_config.TextColumn("Valor Extraído", width="large"),
+            "Estado": st.column_config.TextColumn("Estado", width="small")
+        }
+    )
+    
+    if any(fields.values()):
+        # Crear JSON con los datos extraídos
+        export_data = {
+            'timestamp': datetime.now().isoformat(),
+            'campos_extraidos': fields,
+            'resumen': {
+                'total_campos': len(field_labels),
+                'campos_detectados': len([v for v in fields.values() if v]),
+                'porcentaje_completitud': len([v for v in fields.values() if v]) / len(field_labels) * 100
+            }
+        }
+        
+        st.download_button(
+            label="📥 Descargar Datos Extraídos (JSON)",
+            data=json.dumps(export_data, indent=2, ensure_ascii=False),
+            file_name=f"comprobante_bancario_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+            mime="application/json"
+        )
+
+def process_banking_receipt(uploaded_file, analyzer: BankingReceiptAnalyzer) -> None:
+    """Procesa un comprobante bancario completo"""
+    try:
+        # Leer bytes del archivo
+        image_bytes = uploaded_file.read()
+        
+        # Mostrar vista previa
+        st.subheader("🖼️ Vista Previa del Comprobante")
+        image = Image.open(io.BytesIO(image_bytes))
+        st.image(image, caption=f"Comprobante: {uploaded_file.name}", width=300)
+        
+        # Crear tabs para diferentes métodos de análisis
+        tab1, tab2 = st.tabs(["📄 Análisis con Textract", "🔍 Extracción Simple"])
+        
+        # Tab 1: Análisis con Textract Forms
+        with tab1:
+            st.info("📋 Usando Amazon Textract con análisis de formularios")
+            if st.button("Analizar con Textract", key="textract_btn", type="primary"):
+                with st.spinner("Analizando estructura del documento..."):
+                    result = analyzer.analyze_document_with_forms(image_bytes)
+                
+                if result["success"]:
+                    st.success("✅ Análisis completado")
+                    
+                    # Extraer texto de los bloques
+                    text_blocks = []
+                    for block in result["blocks"]:
+                        if block['BlockType'] == 'LINE':
+                            text_blocks.append(block['Text'])
+                    
+                    full_text = '\n'.join(text_blocks)
+                    
+                    # Extraer campos bancarios
+                    banking_fields = BankingDataExtractor.extract_banking_fields(full_text)
+                    display_extracted_banking_data(banking_fields)
+                    
+                    # Mostrar texto completo en expandible
+                    with st.expander("Ver texto completo extraído"):
+                        st.text_area("Texto detectado:", full_text, height=300)
+                else:
+                    st.error(f"❌ Error: {result['error']}")
+        
+        # Tab 2: Extracción simple
+        with tab2:
+            st.info("🔍 Extracción simple de texto y análisis con patrones")
+            if st.button("Extracción Simple", key="simple_btn"):
+                with st.spinner("Extrayendo texto..."):
+                    result = analyzer.extract_text_simple(image_bytes)
+                
+                if result["success"]:
+                    st.success("✅ Extracción completada")
+                    
+                    # Extraer campos bancarios
+                    banking_fields = BankingDataExtractor.extract_banking_fields(result["text"])
+                    display_extracted_banking_data(banking_fields)
+                    
+                    # Mostrar texto original
+                    with st.expander("Ver texto extraído"):
+                        st.text_area("Texto:", result["text"], height=200)
+                else:
+                    st.error(f"❌ Error: {result['error']}")
+                    
+    except Exception as e:
+        st.error(f"❌ Error al procesar comprobante: {str(e)}")
+
+def main():
+    """Función principal de la aplicación"""
+    
+    # Título y descripción
+    st.title("🏦 Analizador de Comprobantes Bancarios")
+    st.markdown("""
+    Esta aplicación especializada extrae información específica de comprobantes bancarios usando:
+    - 📄 **Amazon Textract** con análisis de formularios
+    - 🔍 **Patrones de reconocimiento** específicos para datos bancarios
+    """)
+    
+    # Inicializar analizador
+    analyzer = BankingReceiptAnalyzer()
+    
+    if not analyzer.credentials_valid:
+        st.error("❌ No se pudieron cargar las credenciales de AWS")
+        st.stop()
+    
+    # Sidebar con información
+    with st.sidebar:
+        st.header("🎯 Campos Detectables")
+        st.markdown("""
+        **Información Financiera:**
+        - 💰 Importe enviado
+        - 💳 Comisión
+        - 📊 ITF
+        
+        **Datos de Operación:**
+        - 🔢 Número de operación
+        - 📝 Tipo de operación  
+        - 📅 Fecha y hora
+        - ✅ Estado de operación
+        
+        **Información de Cuentas:**
+        - 🏦 Entidad destino
+        - 📤 Cuenta origen
+        - 📥 Cuenta destino
+        """)
+    
+    # Subida de archivos
+    st.header("📤 Subir Comprobante Bancario")
+    uploaded_file = st.file_uploader(
+        "Selecciona una imagen del comprobante bancario:",
+        type=['jpg', 'jpeg', 'png', 'pdf'],
+        help="Sube una imagen clara del comprobante para extraer la información automáticamente"
+    )
+    
+    if uploaded_file is not None:
+        # Procesar archivo
+        if uploaded_file.type.startswith('image/'):
+            process_banking_receipt(uploaded_file, analyzer)
+        elif uploaded_file.type == 'application/pdf':
+            st.warning("⚠️ Los PDFs se procesarán como imágenes. Para mejores resultados, usa imágenes JPG/PNG.")
+            process_banking_receipt(uploaded_file, analyzer)
+        else:
+            st.error("❌ Formato no soportado. Usa JPG, PNG o PDF.")
+    
+    # Información adicional
+    st.markdown("---")
+    st.header("📚 Información Adicional")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("🏦 Bancos Soportados")
+        st.markdown("""
+        - BBVA
+        - Plin
+        - BCP
+        - Interbank
+        - Scotiabank
+        - BanBif
+        - Y otros...
+        """)
+    
+    with col2:
+        st.subheader("📋 Tipos de Operación")
+        st.markdown("""
+        - Envío a contactos
+        - Transferencias
+        - Pagos de servicios
+        - Recargas
+        - Y otros...
+        """)
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style='text-align: center; color: #666;'>
+        <p>🏦 Analizador de Comprobantes Bancarios - Desarrollado con Streamlit y AWS por <a href="https://github.com/JoseJeampierJaraSalas1997" target="_blank">@JoseJeampierJaraSalas1997</a></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+streamlit
+boto3
+botocore
+Pillow
+PyPDF2