Una aplicación web completa que incluye una calculadora aritmética básica y una calculadora especializada para análisis de redes IP (IPv4 e IPv6).

• Operaciones básicas: suma, resta, multiplicación, división
• Interfaz intuitiva con teclado virtual y soporte de teclado físico
• Validación de expresiones en tiempo real

• Cálculo de Subred IPv4: Información completa de subred (dirección de red, broadcast, máscara, hosts usables, etc.)
• Información de Clase IPv4: Determina la clase (A, B, C, D, E) y características de una dirección IP
• Conversión Binario/Decimal: Convierte entre formatos binario y decimal, y entre IPv4 y binario
• Verificación de Rango IP: Verifica si una IP está dentro de un rango específico
• Cálculo de Subred IPv6: Información de subred para direcciones IPv6

• Backend: Python 3, Flask, Flask-CORS
• Frontend: HTML5, CSS3, JavaScript vanilla
• Librerías de red: ipaddress (Python estándar)

1. Python 3.7 o superior

   • Windows: Descargar de python.org
   • macOS: brew install python3 o descargar de python.org
   • Linux: sudo apt-get install python3 python3-pip (Debian/Ubuntu) o equivalente

2. Git (opcional, para clonar el repositorio)

   • Windows: Descargar de git-scm.com
   • macOS: xcode-select --install o brew install git
   • Linux: sudo apt-get install git

# Clonar el repositorio (si usas git)
git clone https://github.com/tu-usuario/calculadora-multifuncional.git
cd calculadora-multifuncional

# Crear entorno virtual
python -m venv venv

# Activar entorno virtual
venv\Scripts\activate

# Instalar dependencias
pip install flask flask-cors

# Ejecutar la aplicación
python app.py

# Clonar el repositorio (si usas git)
git clone https://github.com/tu-usuario/calculadora-multifuncional.git
cd calculadora-multifuncional

# Crear entorno virtual
python3 -m venv venv

# Activar entorno virtual
source venv/bin/activate

# Instalar dependencias
pip install flask flask-cors

# Ejecutar la aplicación
python3 app.py

# Crear Dockerfile
cat > Dockerfile << 'EOF'
FROM python:3.9-slim
WORKDIR /app
COPY . .
RUN pip install flask flask-cors
EXPOSE 5000
CMD ["python", "app.py"]
EOF

# Construir imagen
docker build -t calculadora .

# Ejecutar contenedor
docker run -p 5000:5000 calculadora

1. Abre tu navegador y navega a http://localhost:5000
2. Selecciona la pestaña deseada:
   • Calculadora: Para operaciones aritméticas básicas
   • Calculadora IP: Para análisis de redes
3. En la calculadora IP, selecciona la operación deseada del menú desplegable

calculadora-multifuncional/
├── app.py              # Backend Flask
├── index.html          # Interfaz principal
├── script.js           # Lógica del frontend
├── style.css           # Estilos CSS
├── requirements.txt    # Dependencias Python (recomendado)
├── Dockerfile          # Configuración Docker (opcional)
├── README.md           # Este archivo
└── .gitignore          # Archivos ignorados por Git

Endpoint: /calcular Método: POST Body:

{
  "expresion": "2 + 2"
}

Respuesta:

{
  "resultado": 4
}

Endpoint: /ip/subred Método: POST Body:

{
  "ip": "192.168.1.0",
  "cidr": 24
}

Endpoint: /ip/clase Método: POST Body:

{
  "ip": "192.168.1.1"
}

Endpoint: /ip/convertir Método: POST Body:

{
  "tipo": "ipv4-a-binario",
  "entrada": "192.168.1.1"
}

Endpoint: /ip/rango Método: POST Body:

{
  "inicio": "192.168.1.1",
  "fin": "192.168.1.254",
  "verificar": "192.168.1.100"
}

Endpoint: /ip/ipv6-subred Método: POST Body:

{
  "ip": "2001:0db8:85a3::8a2e:0370:7334",
  "prefijo": 64
}

1. Crear archivo requirements.txt:

pip freeze > requirements.txt

2. Crear Procfile:

web: gunicorn app:app

3. Crear runtime.txt:

python-3.9.18

4. Instalar CLI de Heroku y desplegar:

# Instalar Heroku CLI (https://devcenter.heroku.com/articles/heroku-cli)
heroku login
heroku create mi-calculadora
git push heroku main
heroku open

1. Instalar EB CLI:

pip install awsebcli

2. Inicializar y desplegar:

eb init -p python-3.9 mi-calculadora
eb create mi-calculadora-env
eb deploy
eb open

1. Crear Dockerfile (como se muestra arriba)

2. Construir y desplegar:

gcloud builds submit --tag gcr.io/mi-proyecto/calculadora
gcloud run deploy --image gcr.io/mi-proyecto/calculadora --platform managed

1. Conectar repositorio GitHub
2. Configurar build command: pip install -r requirements.txt
3. Configurar run command: gunicorn app:app
4. Desplegar

docker-compose.yml:

version: '3.8'
services:
  calculadora:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=production
      - FLASK_APP=app.py
    restart: unless-stopped

Ejecutar:

docker-compose up -d

import os

if __name__ == '__main__':
    # Configuración para producción
    app.run(debug=False, host='0.0.0.0', port=int(os.environ.get('PORT', 5000)))

Importante: En producción, actualiza las URLs en script.js para apuntar a tu servidor:

// Cambiar de:
const response = await fetch('http://127.0.0.1:5000/calcular', {

// A:
const response = await fetch('https://mi-servidor.com/calcular', {

O mejor aún, usar una variable de entorno:

const API_BASE_URL = process.env.API_BASE_URL || 'http://127.0.0.1:5000';
const response = await fetch(`${API_BASE_URL}/calcular`, {

Crear archivo .env (no committear):

FLASK_ENV=production
SECRET_KEY=tu-clave-secreta-aqui
PORT=5000

ADVERTENCIA DE SEGURIDAD: Este proyecto utiliza eval() para evaluar expresiones aritméticas, lo cual es EXTREMADAMENTE PELIGROSO en producción. El uso de eval() permite ejecución arbitraria de código.

Para producción, DEBES reemplazar eval() con un evaluador de expresiones seguro:

# En app.py, reemplazar:
resultado = eval(expresion)

# Con un evaluador seguro como:
import ast
import operator

def safe_eval(expr):
    """Evalúa expresiones aritméticas de forma segura"""
    allowed_operators = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.USub: operator.neg,
        ast.Pow: operator.pow,
    }
    
    try:
        node = ast.parse(expr, mode='eval').body
        return _eval_node(node, allowed_operators)
    except:
        raise ValueError("Expresión no válida")

def _eval_node(node, operators):
    if isinstance(node, ast.Constant):
        return node.value
    elif isinstance(node, ast.BinOp):
        left = _eval_node(node.left, operators)
        right = _eval_node(node.right, operators)
        return operators[type(node.op)](left, right)
    elif isinstance(node, ast.UnaryOp):
        operand = _eval_node(node.operand, operators)
        return operators[type(node.op)](operand)
    else:
        raise ValueError("Operación no permitida")

Otras consideraciones de seguridad:

1. Implementar autenticación si es necesario
2. Usar HTTPS en producción
3. Configurar CORS apropiadamente:

from flask_cors import CORS

CORS(app, resources={
    r"/api/*": {
        "origins": ["https://mi-dominio.com"],
        "methods": ["GET", "POST"],
        "allow_headers": ["Content-Type"]
    }
})

4. Limitar la tasa de solicitudes (rate limiting)
5. Validar y sanitizar todas las entradas del usuario

Causa: El frontend no puede alcanzar el backend Solución:

1. Asegúrate de que Flask esté corriendo en http://localhost:5000
2. Verifica que no haya firewall bloqueando el puerto 5000
3. En producción, actualiza las URLs en script.js para apuntar al servidor correcto

Causa: Restricciones de mismo origen del navegador Solución:

# En app.py
from flask_cors import CORS
CORS(app, resources={r"/*": {"origins": "*"}})

Solución:

set FLASK_APP=app.py
set FLASK_ENV=development
python -m flask run

1. Fork el proyecto
2. Crea tu rama de feature (git checkout -b feature/nueva-funcionalidad)
3. Commit tus cambios (git commit -m 'Add nueva-funcionalidad')
4. Push a la rama (git push origin feature/nueva-funcionalidad)
5. Abre un Pull Request

Este proyecto está bajo la Licencia MIT - ver el archivo LICENSE para detalles.

• Autor: Gustavo Rivera
• Email: [email protected]
• GitHub: @gadriv

Agregar logging a app.py:

import logging
from logging.handlers import RotatingFileHandler

# Configurar logging
if not app.debug:
    file_handler = RotatingFileHandler('app.log', maxBytes=10240, backupCount=10)
    file_handler.setFormatter(logging.Formatter(
        '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
    ))
    file_handler.setLevel(logging.INFO)
    app.logger.addHandler(file_handler)
    app.logger.setLevel(logging.INFO)
    app.logger.info('Calculadora iniciada')

@app.errorhandler(404)
def not_found_error(error):
    return jsonify({'error': 'Recurso no encontrado'}), 404

@app.errorhandler(500)
def internal_error(error):
    app.logger.error(f'Error interno: {error}')
    return jsonify({'error': 'Error interno del servidor'}), 500

Instalar flask-limiter:

pip install flask-limiter

Agregar a app.py:

from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

# Aplicar rate limiting a endpoints específicos
@app.route('/calcular', methods=['POST'])
@limiter.limit("10 per minute")
def calcular():
    # ... resto del código

from flask_compress import Compress

Compress(app)

• Calculadora aritmética básica
• Funciones de cálculo de red IP
• Interfaz responsive
• Soporte multiplataforma
• Instrucciones de despliegue en la nube
• Consideraciones de seguridad
• Mejoras recomendadas para producción