Alertas Institucionales con SMC: Mejora tu Trading

Alertas Institucionales con SMC: Mejora tu Trading

Este script SMC_BOS_FVG_OB_Pinbar_Sessions_Alerts, es un modelo institucional diseñado para identificar zonas de alta probabilidad basadas en estructura, liquidez y confirmación de intención. Su objetivo es estandarizar la lectura del mercado y ejecutar únicamente cuando se cumplen condiciones institucionales verificables.

A continuación, el manual que documenta la metodología, reglas operativas y ejemplos visuales para su aplicación profesional.

🎯 Objetivo

Este enfoque se fundamenta en:

  • Identificar dónde el mercado toma liquidez.
  • Esperar una ruptura estructural real (BOS).
  • Confirmar intención mediante pinbar institucional.
  • Ejecutar únicamente en mitigación institucional (FVG u OB).
  • Validar con la siguiente vela.
  • Filtrar por RR mínimo y sesión operativa.

Este proceso tiene el objetivo de eliminar ruido, reducir entradas falsas y alinear la ejecución con el comportamiento de mesas institucionales.

⚙️ Configuración Inicial

ParámetroDescripciónRecomendación
Left / Right barsSensibilidad de pivotes2–3 para intradía
RR mínimoRatio mínima para alertar entrada1.5 o superior
SesiónFiltro horarioAsia / Londres / NY según tu operativa
Dibujar zonaVisualización de FVG/OBActivado para backtest, desactivado para ejecución
AlertasActivar/desactivar eventosMantén activadas las de entrada y toque

🔍 Jerarquía de Confirmación

  1. Liquidity Taken → se limpia un extremo previo.
  2. Break of Structure (BOS) → ruptura real del último swing.
  3. Pinbar → rechazo fuerte institucional.
  4. Zona más cercana (FVG u OB) → punto de mitigación.
  5. Toque real de zona → precio entra en la zona.
  6. Confirmación de la siguiente vela → dirección validada.
  7. RR ≥ X y sesión válida → entrada activada.

🧩 Alertas Institucionales

El sistema genera alertas para:

  • BOS
  • Pinbar
  • Toque
  • Entrada

Cada alerta incluye:

  • Dirección (LONG/SHORT)
  • Entry
  • SL
  • TP
  • RR
  • Sesión

Esto permite operar sin estar pegado al gráfico.

TipoDescripciónMensaje 
BOSRuptura estructural“BOS ALCISTA/BAJISTA detectado” 
PinbarRechazo fuerte“Pinbar ALCISTA/BAJISTA detectado” 
ToqueMitigación real“TOQUE de zona (LONG/SHORT)” 
EntradaConfirmación completa“ENTRY LONG/SHORT ACTIVADAEntry: XSL: YTP: ZRR: nSesión: NY”

🧠 Interpretación Visual

  • Líneas amarillas: FVG (rango de desequilibrio).
  • Líneas naranjas: OB (última vela institucional).
  • Líneas rojas / verdes: SL y TP.
  • Línea amarilla continua: punto de entrada.

🧩 Reglas de Ejecución

  • No se anticipan entradas.
  • No se opera sin BOS.
  • No se opera sin pinbar.
  • No se opera sin toque real.
  • No se opera sin confirmación de la siguiente vela.
  • No se opera si RR < mínimo.
  • No se opera fuera de sesión.
  • SL siempre en el swing que generó la liquidez.
  • TP automático a 2R.

🧮 Optimización sugerida

SesiónCaracterísticasRecomendación
AsiaRango y acumulaciónPreparar liquidez
LondresExpansiónMayor frecuencia de BOS
NYManipulaciónMejor confirmación

Conclusiones

El sistema SMC Sniper permite ejecutar con precisión institucional, eliminando ruido y estandarizando la lectura del mercado. Su fortaleza radica en la secuencia lógica y la disciplina operativa.

Script para Pine

//@version=5
indicator("SMC_BOS_FVG_OB_Pinbar_Sessions_Alerts", overlay = true, max_labels_count = 500, max_lines_count = 500)
//---------------------------------------------------------
// INPUTS
//---------------------------------------------------------
left = input.int(2, "Left bars")
right = input.int(2, "Right bars")
showZone = input.bool(true, "Dibujar zona elegida (FVG u OB)")
// Alertas
alertBOS = input.bool(true, "Alerta: BOS detectado")
alertPinbar = input.bool(true, "Alerta: Pinbar detectado")
alertTouch = input.bool(true, "Alerta: Toque de zona")
alertEntry = input.bool(true, "Alerta: Entrada confirmada")
// Filtro de RR mínimo (ratio)
minRR = input.float(1.5, "RR minimo para alertar entrada", step = 0.1)
// Filtro de sesión
sessionChoice = input.string("Londres", "Sesion para alertar entrada", options = ["Asia", "Londres", "Nueva York"])
//---------------------------------------------------------
// SESIONES (ajusta horarios a tu broker si hace falta)
//---------------------------------------------------------
asiaSession = time(timeframe.period, "1800-0000")
londonSession = time(timeframe.period, "0200-0500")
newYorkSession = time(timeframe.period, "0700-1100")
inAsia = not na(asiaSession)
inLondon = not na(londonSession)
inNewYork = not na(newYorkSession)
sessionOK =
(sessionChoice == "Asia" and inAsia) or
(sessionChoice == "Londres" and inLondon) or
(sessionChoice == "Nueva York" and inNewYork)
//---------------------------------------------------------
// 1. Swings (estructura + liquidez)
//---------------------------------------------------------
swingHigh = ta.pivothigh(high, left, right)
swingLow = ta.pivotlow(low, left, right)
var float lastHigh = na
var float lastLow = na
if not na(swingHigh)
lastHigh := swingHigh
if not na(swingLow)
lastLow := swingLow
//---------------------------------------------------------
// 2. Liquidity Taken
//---------------------------------------------------------
liqBuy = not na(lastHigh) and high > lastHigh
liqSell = not na(lastLow) and low < lastLow
//---------------------------------------------------------
// 3. BOS
//---------------------------------------------------------
bosBull = liqBuy and close > lastHigh
bosBear = liqSell and close < lastLow
//---------------------------------------------------------
// 4. FVG
//---------------------------------------------------------
bullFVG = low[1] > high[2]
bearFVG = high[1] < low[2]
var float fvgTop = na
var float fvgBot = na
if bullFVG
fvgTop := low[1]
fvgBot := high[2]
if bearFVG
fvgTop := high[2]
fvgBot := low[1]
//---------------------------------------------------------
// 5. OB (Order Block)
//---------------------------------------------------------
var float obHigh = na
var float obLow = na
if bosBull
obHigh := high[1]
obLow := low[1]
if bosBear
obHigh := high[1]
obLow := low[1]
//---------------------------------------------------------
// 6. Pinbar Confirmation
//---------------------------------------------------------
body = math.abs(close - open)
upperWick = high - math.max(close, open)
lowerWick = math.min(close, open) - low
pinbarBull = lowerWick >= body * 2 and close > open
pinbarBear = upperWick >= body * 2 and close < open
//---------------------------------------------------------
// 7. ELECCION AUTOMATICA: FVG u OB (la mas cercana)
//---------------------------------------------------------
var float zone = na
var bool isFVG = false
// LONG
if bosBull and pinbarBull and not na(fvgBot) and not na(obHigh)
distFVG = math.abs(close - fvgBot)
distOB = math.abs(close - obHigh)
if distFVG < distOB
zone := fvgBot
isFVG := true
else
zone := obHigh
isFVG := false
// SHORT
if bosBear and pinbarBear and not na(fvgTop) and not na(obLow)
distFVG = math.abs(close - fvgTop)
distOB = math.abs(close - obLow)
if distFVG < distOB
zone := fvgTop
isFVG := true
else
zone := obLow
isFVG := false
//---------------------------------------------------------
// 8. TOQUE DE ZONA
//---------------------------------------------------------
touch = not na(zone) and low <= zone and high >= zone
//---------------------------------------------------------
// 9. CONFIRMACION DE LA SIGUIENTE VELA
//---------------------------------------------------------
bullNextConfirm = touch[1] and close > open and close > (low + (high - low) * 0.5)
bearNextConfirm = touch[1] and close < open and close < (high - (high - low) * 0.5)
//---------------------------------------------------------
// 10. ENTRADA FINAL + RR (ratio)
//---------------------------------------------------------
var float entry = na
var float sl = na
var float tp = na
var float rrRatio = na
// LONG
if bullNextConfirm
entry := zone[1]
sl := lastLow
tp := entry + (entry - sl) * 2.0
risk = math.abs(entry - sl)
reward = math.abs(tp - entry)
rrRatio := risk > 0 ? reward / risk : na
// SHORT
if bearNextConfirm
entry := zone[1]
sl := lastHigh
tp := entry - (sl - entry) * 2.0
risk = math.abs(sl - entry)
reward = math.abs(entry - tp)
rrRatio := risk > 0 ? reward / risk : na
//---------------------------------------------------------
// 11. DIBUJAR ZONA ELEGIDA
//---------------------------------------------------------
if showZone and not na(zone)
if isFVG
line.new(bar_index, fvgTop, bar_index - 1, fvgTop, extend = extend.right, color = color.new(color.yellow, 70))
line.new(bar_index, fvgBot, bar_index - 1, fvgBot, extend = extend.right, color = color.new(color.yellow, 70))
else
line.new(bar_index, zone, bar_index - 1, zone, extend = extend.right, color = color.new(color.orange, 70))
//---------------------------------------------------------
// 12. PLOTS
//---------------------------------------------------------
plot(entry, "Entry", color = color.new(color.yellow, 0), style = plot.style_linebr)
plot(sl, "SL", color = color.new(color.red, 0), style = plot.style_linebr)
plot(tp, "TP", color = color.new(color.green, 0), style = plot.style_linebr)
//---------------------------------------------------------
// 13. ALERTAS INSTITUCIONALES (simplificadas)
//---------------------------------------------------------
// BOS
if alertBOS and bosBull
alert("BOS ALCISTA detectado (LONG)", alert.freq_once_per_bar)
if alertBOS and bosBear
alert("BOS BAJISTA detectado (SHORT)", alert.freq_once_per_bar)
// PINBAR
if alertPinbar and pinbarBull
alert("Pinbar ALCISTA detectado", alert.freq_once_per_bar)
if alertPinbar and pinbarBear
alert("Pinbar BAJISTA detectado", alert.freq_once_per_bar)
// TOQUE
if alertTouch and touch
dir = bosBull ? "LONG" : bosBear ? "SHORT" : "NA"
alert("TOQUE de zona (" + dir + ")", alert.freq_once_per_bar)
// ENTRADA FINAL (con filtros RR + sesion)
entryLong = bullNextConfirm and not na(rrRatio) and rrRatio >= minRR and sessionOK
entryShort = bearNextConfirm and not na(rrRatio) and rrRatio >= minRR and sessionOK
if alertEntry and entryLong
msgLong = "ENTRY LONG | Entry: " + str.tostring(entry, format.mintick) +
" | SL: " + str.tostring(sl, format.mintick) +
" | TP: " + str.tostring(tp, format.mintick) +
" | RR: " + str.tostring(rrRatio, format.mintick) +
" | Sesion: " + sessionChoice
alert(msgLong, alert.freq_once_per_bar)
if alertEntry and entryShort
msgShort = "ENTRY SHORT | Entry: " + str.tostring(entry, format.mintick) +
" | SL: " + str.tostring(sl, format.mintick) +
" | TP: " + str.tostring(tp, format.mintick) +
" | RR: " + str.tostring(rrRatio, format.mintick) +
" | Sesion: " + sessionChoice
alert(msgShort, alert.freq_once_per_bar)

Ejemplo visual

En esta imagen vemos la entrada un poco mas arriba de la línea amarilla (por el lag de tiempo del trader), luego del ticker Alcista, triangulo verde a las 820 del 20262005  (este viene del script publicado antes de esta publicación: https://alextorres.consulting/2026/05/15/como-leer-el-mercado-integracion-del-panel-multitimeframe/), nos indica un TP que se cumple una hora después (20260520 0915) y sin tocar SL (línea roja en el gráfico), en un momento volátil del XAUUSD ese 20 de mayo del 2026 que se esperaba las FOMC Meeting Minutes a las 12 pm:

Ilustraciòn tomada de https://www.forexfactory.com

Cómo Leer el Mercado: Integración del Panel Multitimeframe

Cómo Leer el Mercado: Integración del Panel Multitimeframe

Integración del Panel Multitimeframe y el Mapa de Sesiones

🧠 1. Fundamento Institucional

El mercado no se mueve por azar.
Cada desplazamiento responde a intenciones institucionales: acumulación, manipulación y distribución.
El objetivo del trader profesional es leer esas intenciones, no adivinarlas.

Por eso, este sistema combina dos herramientas:

  • Panel Multitimeframe Institucional → lectura fractal de tendencia y fuerza.
  • Mapa de Sesiones → lectura contextual de comportamiento por zonas horarias (Asia, Londres, Nueva York).

Juntas forman una visión completa del flujo institucional:
quién mueve el mercado, cuándo lo hace y hacia dónde lo empuja.

🧩 2. Estructura del análisis

Paso 1 – Análisis macro (D1 y H4)

Empieza con las temporalidades mayores; luego de que la sesión de Nueva York lleva al menos 30 minutos, yo opero en el horario diurno de América.
Dibuja las zonas clave: FVG, fractalidad, order blocks, zonas de liquidez.
Estas líneas son tu mapa institucional: muestran dónde el dinero grande entra o sale.

El Sesgo General del panel te indica si esas zonas están alineadas con el flujo institucional.
Si el sesgo es 🟢 alcista, prioriza zonas de demanda (long o compras); si es 🔴 bajista, enfócate en zonas de oferta (short o ventas).

Paso 2 – Contexto de sesiones

Usa el Mapa de Sesiones para observar cómo actuaron las tres principales zonas horarias:

  • Asia → acumulación o manipulación inicial.
  • Londres → expansión o ruptura.
  • Nueva York → distribución o reversión.

El panel te muestra qué sesión fue la más volátil y su dirección.
Esto te permite entender quién tuvo el control del día y si el movimiento actual tiene respaldo institucional.

Paso 3 – Ejecución operativa (3 m – 5 m – 1 m)

Aquí entra la precisión.
Operas solo con la tendencia del panel inferior izquierdo.
Esperas una reversión local (bajista → alcista o viceversa) y entras con confirmación.

Tu entrada se apoya en:

  • Cambio de color o dirección en el panel.
  • Reacción en zona institucional (FVG, order block, fractal).
  • Confirmación sobre VWAP.

El Sesgo General actúa como filtro maestro:
si el sesgo es alcista, tus compras tienen respaldo institucional; si es bajista, tus ventas están alineadas con el flujo dominante.

⚙️ 3. Fundamento técnico del Sesgo General

La línea Sesgo General resume el comportamiento de las cuatro temporalidades clave (D1, H4, H1, M15) en una sola lectura ejecutiva. Su función es mostrar la coherencia o divergencia institucional entre los distintos marcos de análisis.

🧩 Qué mide exactamente?

  1. Cuenta cuántos timeframes están alineados en dirección alcista o bajista.
  2. Evalúa la fuerza institucional del movimiento:
    • Si 3 o 4 TF coinciden → tendencia sólida y con respaldo institucional.
    • Si 2 TF coinciden → mercado mixto o en transición.
    • Si 1 TF domina → ruido o manipulación local.
  3. Asigna color y texto dinámico:
    • 🟢 Verde → mayoría alcista (sesgo comprador).
    • 🔴 Rojo → mayoría bajista (sesgo vendedor).
    • 🟡 Amarillo → mixto o indeciso.

⚙️ Cómo se interpreta operativamente

SituaciónLectura del Sesgo GeneralAcción sugerida
🟢 Alcista 3/4 TF o 4/4 TFAlta coherencia institucionalBuscar entradas en retrocesos alcistas o confirmaciones sobre VWAP
🔴 Bajista 3/4 TF o 4/4 TFSesgo vendedor dominanteBuscar ventas en retrocesos bajistas o rupturas bajo VWAP
🟡 Mixto 2/4 TFMercado en transiciónEsperar confirmación o consolidación antes de operar

💡 Ventaja institucional

El Sesgo General te da una visión macro instantánea sin cambiar de gráfico. Es como tener un “panel de control” que te dice si el mercado está alineado o fragmentado, permitiéndote:

  • Filtrar operaciones que van contra el flujo institucional.
  • Evitar entradas en zonas de indecisión.
  • Sincronizar tus setups con la dirección dominante del día.

🧘 4. Psicología y disciplina

El Sesgo General también cumple una función psicológica:
te obliga a esperar confirmación, evitando el overtrading y el revenge trading.

  • Si el sesgo no está alineado, no operas.
  • Si el sesgo cambia, revalúas.
  • Si el sesgo confirma, ejecutas con convicción.

La paciencia se convierte en tu ventaja institucional.
Operas solo cuando el mercado y las temporalidades están sincronizados.

5. Scripts utilizados en Pine de TradingView

Panel

//@version=5
indicator("EMAs personalizables + VWAP + Cruces (Modular)", overlay=true)
// === INPUTS DE VISIBILIDAD ===
showEmaShort = input.bool(true, "Mostrar EMA corta")
showEmaLong = input.bool(true, "Mostrar EMA larga")
showVWAP = input.bool(true, "Mostrar VWAP")
showSignals = input.bool(true, "Mostrar cruces")
// === INPUTS DE PERIODOS ===
emaShortLen = input.int(9, "Periodo EMA corta", minval=1)
emaLongLen = input.int(21, "Periodo EMA larga", minval=1)
// === INPUTS DE COLORES ===
emaShortColor = input.color(color.blue, "Color EMA corta")
emaLongColor = input.color(color.orange, "Color EMA larga")
vwapColor = input.color(color.purple, "Color VWAP")
// === INPUTS DE GROSOR ===
emaShortWidth = input.int(2, "Grosor EMA corta", minval=1, maxval=5)
emaLongWidth = input.int(2, "Grosor EMA larga", minval=1, maxval=5)
vwapWidth = input.int(1, "Grosor VWAP", minval=1, maxval=5)
// === INPUTS DE ESTILO ===
emaShortStyleOpt = input.string("line", "Estilo EMA corta", options=["line","histogram","area","columns","circles","stepline"])
emaLongStyleOpt = input.string("line", "Estilo EMA larga", options=["line","histogram","area","columns","circles","stepline"])
vwapStyleOpt = input.string("line", "Estilo VWAP", options=["line","histogram","area","columns","circles","stepline"])
// === CONVERSIÓN DE ESTILO ===
emaShortStyle = emaShortStyleOpt == "histogram" ? plot.style_histogram :
emaShortStyleOpt == "area" ? plot.style_area :
emaShortStyleOpt == "columns" ? plot.style_columns :
emaShortStyleOpt == "circles" ? plot.style_circles :
emaShortStyleOpt == "stepline" ? plot.style_stepline : plot.style_line
emaLongStyle = emaLongStyleOpt == "histogram" ? plot.style_histogram :
emaLongStyleOpt == "area" ? plot.style_area :
emaLongStyleOpt == "columns" ? plot.style_columns :
emaLongStyleOpt == "circles" ? plot.style_circles :
emaLongStyleOpt == "stepline" ? plot.style_stepline : plot.style_line
vwapStyle = vwapStyleOpt == "histogram" ? plot.style_histogram :
vwapStyleOpt == "area" ? plot.style_area :
vwapStyleOpt == "columns" ? plot.style_columns :
vwapStyleOpt == "circles" ? plot.style_circles :
vwapStyleOpt == "stepline" ? plot.style_stepline : plot.style_line
// === EMAs ===
emaShort = ta.ema(close, emaShortLen)
emaLong = ta.ema(close, emaLongLen)
// === VWAP ===
vwapLine = ta.vwap(close)
// === PLOTS ===
plot(showEmaShort ? emaShort : na, title="EMA corta", color=emaShortColor, linewidth=emaShortWidth, style=emaShortStyle)
plot(showEmaLong ? emaLong : na, title="EMA larga", color=emaLongColor, linewidth=emaLongWidth, style=emaLongStyle)
plot(showVWAP ? vwapLine : na, title="VWAP", color=vwapColor, linewidth=vwapWidth, style=vwapStyle)
// === CRUCES ===
cruceAlcista = ta.crossover(emaShort, emaLong)
cruceBajista = ta.crossunder(emaShort, emaLong)
plotshape(showSignals and cruceAlcista, title="Cruce Alcista", style=shape.triangleup, location=location.belowbar, color=color.new(color.lime, 0), size=size.small, text="▲ Alcista")
plotshape(showSignals and cruceBajista, title="Cruce Bajista", style=shape.triangledown, location=location.abovebar, color=color.new(color.red, 0), size=size.small, text="▼ Bajista")
// === ALERTAS ===
alertcondition(cruceAlcista, title="Alerta Cruce Alcista", message="EMA corta cruzó arriba de EMA larga")
alertcondition(cruceBajista, title="Alerta Cruce Bajista", message="EMA corta cruzó abajo de EMA larga")
// === PANEL INSTITUCIONAL MULTITF (CORREGIDO + SESGO GENERAL) ===
// === CÁLCULOS BASE TF ACTUAL ===
diff = math.abs(emaShort - emaLong)
maxDiff = ta.highest(diff, 200)
intensity = maxDiff == 0.0 ? 0.0 : diff / maxDiff
fuerzaPct = math.round(intensity * 100)
tendencia = emaShort > emaLong ? "Alcista" : emaShort < emaLong ? "Bajista" : "Neutral"
vwapEstado = close > vwapLine ? "Sobre VWAP" : close < vwapLine ? "Bajo VWAP" : "En VWAP"
// === COLOR PARA TF ACTUAL Y VWAP ===
colorActual = emaShort > emaLong ? color.lime : emaShort < emaLong ? color.red : color.yellow
colorVWAP = close > vwapLine ? color.lime : close < vwapLine ? color.red : color.yellow
// === FUNCIÓN MULTITF (datos + color) ===
f_tfData(tf) =>
emaS = request.security(syminfo.tickerid, tf, ta.ema(close, emaShortLen))
emaL = request.security(syminfo.tickerid, tf, ta.ema(close, emaLongLen))
d = math.abs(emaS - emaL)
maxD = request.security(syminfo.tickerid, tf, ta.highest(math.abs(emaS - emaL), 200))
inten = maxD == 0.0 ? 0.0 : d / maxD
fuerza = math.round(inten * 100)
tend = emaS > emaL ? "Alcista" : emaS < emaL ? "Bajista" : "Neutral"
col = emaS > emaL ? color.lime : emaS < emaL ? color.red : color.yellow
[tend, fuerza, col]
// === MULTITIMEFRAME ===
[d1T, d1F, d1C] = f_tfData("D")
[h4T, h4F, h4C] = f_tfData("240")
[h1T, h1F, h1C] = f_tfData("60")
[m15T, m15F, m15C] = f_tfData("15")
// === SESGO GENERAL ===
alcistas = (d1T == "Alcista" ? 1 : 0) + (h4T == "Alcista" ? 1 : 0) + (h1T == "Alcista" ? 1 : 0) + (m15T == "Alcista" ? 1 : 0)
bajistas = (d1T == "Bajista" ? 1 : 0) + (h4T == "Bajista" ? 1 : 0) + (h1T == "Bajista" ? 1 : 0) + (m15T == "Bajista" ? 1 : 0)
sesgoGeneral = alcistas > bajistas ? "🟢 Alcista " + str.tostring(alcistas) + "/4 TF" :
bajistas > alcistas ? "🔴 Bajista " + str.tostring(bajistas) + "/4 TF" : "🟡 Mixto"
sesgoColor = alcistas > bajistas ? color.lime : bajistas > alcistas ? color.red : color.yellow
// === PANEL ===
var table infoPanel = table.new(position.bottom_left, 2, 8, border_width=1, frame_color=color.new(color.white, 80))
// Encabezados
table.cell(infoPanel, 0, 0, "TF Actual", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 1, "D1", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 2, "H4", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 3, "H1", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 4, "M15", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 5, "VWAP", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 6, "Sesgo General", text_color=color.white, bgcolor=color.black)
table.cell(infoPanel, 0, 7, "", text_color=color.white, bgcolor=color.black)
// Valores
table.cell(infoPanel, 1, 0, tendencia + ", " + str.tostring(fuerzaPct) + "%", text_color=colorActual, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 1, d1T + ", " + str.tostring(d1F) + "%", text_color=d1C, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 2, h4T + ", " + str.tostring(h4F) + "%", text_color=h4C, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 3, h1T + ", " + str.tostring(h1F) + "%", text_color=h1C, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 4, m15T + ", " + str.tostring(m15F) + "%", text_color=m15C, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 5, vwapEstado, text_color=colorVWAP, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 6, sesgoGeneral, text_color=sesgoColor, bgcolor=color.new(color.black, 0))
table.cell(infoPanel, 1, 7, "", text_color=sesgoColor, bgcolor=color.new(color.black, 0))

Panel de Sesiones

//@version=5
indicator("Panel Sesiones – OHLC + Rango + Dirección + Resumen", overlay=true, max_labels_count=500)
//────────────────────────────────────────────
// INPUTS
//────────────────────────────────────────────
showPanel = input.bool(true, "Mostrar Panel")
showAsia = input.bool(true, "Asia")
showLondon = input.bool(true, "Londres")
showNY = input.bool(true, "Nueva York")
// Timeframe fijo configurable
fixedTF = input.timeframe("5", "Timeframe fijo para cálculos")
useFixedTF = input.bool(true, "Usar timeframe fijo para cálculos")
// Sesiones (CST México)
asiaSess = input.session("0000-0500", "Sesión Asia")
londonSess = input.session("0200-1000", "Sesión Londres")
nySess = input.session("0730-1500", "Sesión Nueva York")
// Columnas
colShowSession = input.bool(true, "Columna: Sesión")
colShowOpen = input.bool(true, "Columna: Apertura")
colShowHigh = input.bool(true, "Columna: Máximo")
colShowLow = input.bool(true, "Columna: Mínimo")
colShowClose = input.bool(true, "Columna: Cierre")
colShowRange = input.bool(true, "Columna: Rango")
colShowDirection = input.bool(true, "Columna: Dirección")
// Colores
colorAsia = color.new(color.gray, 0)
colorLondon = color.new(color.blue, 0)
colorNY = color.new(color.orange, 0)
//────────────────────────────────────────────
// FUNCIONES
//────────────────────────────────────────────
inSession(sess) =>
time(timeframe.period, sess) != 0
f_sessionOHLC(sess) =>
var float hi = na
var float lo = na
var float op = na
var float cl = na
if inSession(sess)
hi := na(hi) ? high : math.max(hi, high)
lo := na(lo) ? low : math.min(lo, low)
op := na(op) ? open : op
cl := close
[op, hi, lo, cl]
f_sessionClosed(sess) =>
not inSession(sess) and inSession(sess)[1]
//────────────────────────────────────────────
// TIMEFRAME BASE
//────────────────────────────────────────────
tfSource = useFixedTF ? fixedTF : timeframe.period
[asiaOp, asiaHi, asiaLo, asiaCl] = request.security(syminfo.tickerid, tfSource, f_sessionOHLC(asiaSess))
[londonOp, londonHi, londonLo, londonCl] = request.security(syminfo.tickerid, tfSource, f_sessionOHLC(londonSess))
[nyOp, nyHi, nyLo, nyCl] = request.security(syminfo.tickerid, tfSource, f_sessionOHLC(nySess))
//────────────────────────────────────────────
// VALORES FINALES DE SESIÓN (INDEPENDIENTES DEL TF DEL GRÁFICO)
//────────────────────────────────────────────
var float asiaOpFinal = na
var float asiaHiFinal = na
var float asiaLoFinal = na
var float asiaClFinal = na
var float londonOpFinal = na
var float londonHiFinal = na
var float londonLoFinal = na
var float londonClFinal = na
var float nyOpFinal = na
var float nyHiFinal = na
var float nyLoFinal = na
var float nyClFinal = na
// Detectar cierre de sesión usando el timeframe fijo
[asiaClosed, londonClosed, nyClosed] = request.security(syminfo.tickerid, tfSource, [f_sessionClosed(asiaSess), f_sessionClosed(londonSess), f_sessionClosed(nySess)])
if asiaClosed
asiaOpFinal := asiaOp[1]
asiaHiFinal := asiaHi[1]
asiaLoFinal := asiaLo[1]
asiaClFinal := asiaCl[1]
if londonClosed
londonOpFinal := londonOp[1]
londonHiFinal := londonHi[1]
londonLoFinal := londonLo[1]
londonClFinal := londonCl[1]
if nyClosed
nyOpFinal := nyOp[1]
nyHiFinal := nyHi[1]
nyLoFinal := nyLo[1]
nyClFinal := nyCl[1]
//────────────────────────────────────────────
// PANEL
//────────────────────────────────────────────
var table panel = table.new(position.top_right, 7, 5, border_width=1)
// Variables para resumen fijo
var string resumenFijo = na
var color colorFijo = na
f_fillRow(_row, _name, _op, _hi, _lo, _cl, _bgColor) =>
dir = (not na(_cl) and not na(_op)) ? (_cl > _op ? "Alcista" : _cl < _op ? "Bajista" : "Neutro") : "-"
rangeVal = (not na(_hi) and not na(_lo)) ? _hi - _lo : na
rangeStr = not na(rangeVal) ? str.tostring(rangeVal, format.mintick) : "-"
if colShowSession
table.cell(panel, 0, _row, _name, bgcolor=_bgColor)
if colShowOpen
table.cell(panel, 1, _row, na(_op) ? "-" : str.tostring(_op, format.mintick), bgcolor=_bgColor)
if colShowHigh
table.cell(panel, 2, _row, na(_hi) ? "-" : str.tostring(_hi, format.mintick), bgcolor=_bgColor)
if colShowLow
table.cell(panel, 3, _row, na(_lo) ? "-" : str.tostring(_lo, format.mintick), bgcolor=_bgColor)
if colShowClose
table.cell(panel, 4, _row, na(_cl) ? "-" : str.tostring(_cl, format.mintick), bgcolor=_bgColor)
if colShowRange
table.cell(panel, 5, _row, rangeStr, bgcolor=_bgColor)
if colShowDirection
table.cell(panel, 6, _row, dir, bgcolor=_bgColor)
[rangeVal, dir]
//────────────────────────────────────────────
// RENDER PANEL + RESUMEN
//────────────────────────────────────────────
if showPanel
// Encabezados
table.cell(panel, 0, 0, "SESIÓN", bgcolor=color.black, text_color=color.white)
table.cell(panel, 1, 0, "APERTURA", bgcolor=color.black, text_color=color.white)
table.cell(panel, 2, 0, "MÁXIMO", bgcolor=color.black, text_color=color.white)
table.cell(panel, 3, 0, "MÍNIMO", bgcolor=color.black, text_color=color.white)
table.cell(panel, 4, 0, "CIERRE", bgcolor=color.black, text_color=color.white)
table.cell(panel, 5, 0, "RANGO", bgcolor=color.black, text_color=color.white)
table.cell(panel, 6, 0, "DIRECCIÓN", bgcolor=color.black, text_color=color.white)
row = 1
[rangeAsia, dirAsia] = f_fillRow(row, "Asia", asiaOpFinal, asiaHiFinal, asiaLoFinal, asiaClFinal, color.new(colorAsia, 80))
row += 1
[rangeLondon, dirLondon] = f_fillRow(row, "Londres", londonOpFinal, londonHiFinal, londonLoFinal, londonClFinal, color.new(colorLondon, 80))
row += 1
[rangeNY, dirNY] = f_fillRow(row, "Nueva York", nyOpFinal, nyHiFinal, nyLoFinal, nyClFinal, color.new(colorNY, 80))
row += 1
//────────────────────────────────────────────
// RESUMEN
//────────────────────────────────────────────
validRanges = array.new_float()
if not na(rangeAsia)
array.push(validRanges, rangeAsia)
if not na(rangeLondon)
array.push(validRanges, rangeLondon)
if not na(rangeNY)
array.push(validRanges, rangeNY)
maxRange = array.size(validRanges) > 0 ? array.max(validRanges) : na
string sesionMasVolatil = "—"
string dirMasVolatil = "—"
if not na(maxRange)
if rangeAsia == maxRange
sesionMasVolatil := "Asia"
dirMasVolatil := dirAsia
else if rangeLondon == maxRange
sesionMasVolatil := "Londres"
dirMasVolatil := dirLondon
else if rangeNY == maxRange
sesionMasVolatil := "Nueva York"
dirMasVolatil := dirNY
string resumen = ""
color colorResumen = color.new(color.gray, 70)
if useFixedTF
if na(resumenFijo) and sesionMasVolatil != "—"
resumenFijo := "Sesión más volátil: " + sesionMasVolatil + " – " + dirMasVolatil
if dirMasVolatil == "Alcista"
colorFijo := color.new(color.green, 0)
else if dirMasVolatil == "Bajista"
colorFijo := color.new(color.red, 0)
else
colorFijo := color.new(color.gray, 70)
resumen := na(resumenFijo) ? "Sesión más volátil: —" : resumenFijo
colorResumen := na(colorFijo) ? color.new(color.gray, 70) : colorFijo
else
resumen := "Sesión más volátil: " + sesionMasVolatil + " – " + dirMasVolatil
if dirMasVolatil == "Alcista"
colorResumen := color.new(color.green, 0)
else if dirMasVolatil == "Bajista"
colorResumen := color.new(color.red, 0)
else
colorResumen := color.new(color.gray, 70)
table.cell(panel, 0, 4, resumen, bgcolor=colorResumen, text_color=color.white)

🧭 6. Conclusión operativa

El sistema completo te da una visión de flujo institucional en tiempo real:

  1. Mapa macro (líneas SMC) → estructura y zonas de reacción.
  2. Mapa de Sesiones → comportamiento por zonas horarias.
  3. Panel Multitimeframe → fuerza y dirección fractal.
  4. Sesgo General → confirmación institucional y disciplina operativa.

Este enfoque no busca adivinar el mercado, sino leerlo con precisión.
Y esa precisión es lo que diferencia al trader impulsivo del trader institucional.

#Trading #ForexTrading #InstitutionalTrading #SmartMoneyConcepts #RiskManagement

7. Resultados de Testing Real

A una semana de pruebas, los resultados son prometedores en XAUUSD.

Interpretación Ejecutiva de Resultados

1. El sistema es rentable, pero aún está en fase de optimización

Una tasa de acierto del 64.18% indica que la lectura de mercado y la selección de entradas tienen una precisión sólida.
Sin embargo, el factor de ganancia de 1.1 revela algo importante:

El sistema gana más veces de las que pierde, pero todavía no capitaliza completamente sus operaciones ganadoras.

En términos institucionales:

  • La ventaja estadística existe.
  • La gestión del trade todavía tiene espacio para mejorar eficiencia.
  • El edge ya es positivo y sostenible si se mantiene la disciplina.

2. El riesgo está relativamente controlado

Los datos muestran:

  • Operaciones ganadoras promedio: +$3.17
  • Operaciones perdedoras promedio: -$5.15

Esto significa que:

  • Las pérdidas individuales son mayores que las ganancias promedio.
  • El sistema depende actualmente de la frecuencia de acierto para mantenerse rentable.

Ejecutivamente, esto sugiere:

Prioridad estratégica:

Mejorar el manejo de salida y dejar correr más las operaciones válidas.

No necesariamente necesitas “ganar más veces”.
Necesitas:

  • aumentar ligeramente el profit promedio,
  • o reducir marginalmente la pérdida promedio.

Con pequeños ajustes, el factor de ganancia podría escalar rápidamente a 1.3–1.5.

3. Excelente control emocional y operativo

El tiempo medio de retención es extremadamente revelador:

Tipo de operaciónTiempo
Ganadoras28 min
Perdedoras34 min

Esto transmite algo muy importante:

No existe una sobreexposición emocional extrema.

La diferencia entre trades positivos y negativos es pequeña.
Eso normalmente significa:

  • disciplina operativa,
  • ejecución consistente,
  • ausencia de “revenge trading” agresivo,
  • y capacidad de cortar operaciones relativamente rápido.

Muchos traders minoristas muestran exactamente lo contrario:

  • pérdidas enormes en duración,
  • ganancias cortas por miedo.

Aquí no se observa ese patrón destructivo.

4. Los resultados grandes confirman capacidad de captura

Las operaciones destacadas en Gold muestran capturas de:

  • +52 USD
  • +33 USD
  • +32 USD
  • +28 USD

Eso confirma que:

  • el sistema sí identifica movimientos con expansión,
  • existe capacidad real de explotar volatilidad,
  • y el trader no depende únicamente de micro-scalps.

Esto es clave porque valida:

“La estrategia puede escalar”.

Diagnóstico Ejecutivo Final

Fortalezas

✅ Alta tasa de acierto
✅ Consistencia operativa
✅ Control emocional visible en tiempos de exposición
✅ Capacidad de capturar movimientos amplios
✅ Sistema estadísticamente positivo

Áreas de mejora

⚠️ Profit factor aún bajo para escalamiento agresivo
⚠️ Ganancia promedio pequeña frente a pérdida promedio
⚠️ Optimización pendiente en gestión de salida y runners

Conclusión Estratégica

Los datos muestran algo más valioso que una simple rentabilidad:

Existe estructura operativa repetible.

Y eso, en trading profesional, es mucho más importante que un resultado aislado.

La consistencia ya está construida.
Ahora el siguiente nivel consiste en:

  • optimizar el R:R,
  • aumentar eficiencia de salida,
  • y convertir precisión en crecimiento exponencial controlado.

Cómo el trabajo remoto transforma el liderazgo actual.

Cómo el trabajo remoto transforma el liderazgo actual.

Una serie de reflexiones sobre liderazgo moderno, cultura y estrategia.

Por Alex Torres.


Introducción

El liderazgo moderno está evolucionando. Las organizaciones ya no dependen únicamente de estructuras jerárquicas, sino de conversaciones estratégicas, decisiones basadas en datos y una comprensión más profunda de cómo se genera —y se comparte— la eficiencia.

Este mini e‑book reúne una serie de reflexiones diseñadas originalmente para LinkedIn, ahora integradas en un formato editorial que permite ver la evolución de un diálogo entre dos generaciones de liderazgo: un director experimentado y un joven director recién ascendido.

A través de seis capítulos, exploramos temas clave como:

  • La eficiencia compartida del trabajo remoto,
  • El liderazgo basado en acompañamiento estratégico,
  • La economía del talento,
  • La cultura organizacional como ventaja competitiva,
  • Los costos ocultos de la ineficiencia,
  • Y el rol del mentor en la empresa híbrida.

Cada capítulo inicia con una microescena que refleja conversaciones reales en entornos cotidianos: una mesa en Starbucks, una sala de juntas, un coworking o un pasillo corporativo. Son momentos breves, pero cargados de significado, donde se construye visión, se cuestionan supuestos y se forman líderes.

Este e‑book está dirigido a directores, gerentes, profesionales de Recursos Humanos, Finanzas y Operaciones, así como a quienes buscan comprender cómo evoluciona el liderazgo en un mundo donde la eficiencia, la cultura y la estrategia están más conectadas que nunca.


Esto no se trata de una historia ficticia, sino de una representación sutil de algo que ocurre todos los días en las organizaciones: líderes con experiencia acompañando a nuevos directores que enfrentan un entorno más complejo, más rápido y exigente.

El joven director de esta narrativa no es un aprendiz; es un profesional capaz, con criterio, pero que está dando sus primeros pasos en la toma de decisiones estratégicas. El mentor no da órdenes: hace preguntas, comparte perspectiva y abre caminos.

Las conversaciones entre ambos son breves, naturales y situadas en contextos reales. No hay dramatismo, solo claridad, análisis y visión compartida.

El WFH más allá del beneficio: un análisis de eficiencia compartida

Estábamos sentados en una mesa de Starbucks revisando indicadores en la tablet. Él, con la mirada fija en los gráficos, comentó:
—Siempre pensé que el WFH era un beneficio para ellos.
Le respondí sin levantar la vista del análisis:
—Es un beneficio… pero también es eficiencia. La pregunta es para quién.

Durante años, el trabajo remoto se presentó como un gesto de flexibilidad hacia el colaborador. Sin embargo, las nuevas generaciones están introduciendo una perspectiva más pragmática: el WFH también reduce costos operativos para la empresa.

Puntos clave

Para el colaborador:

  • Ahorro en transporte.
  • Menos gastos diarios.
  • Recuperación de tiempo.
  • Mayor autonomía.

Para la empresa:

  • Menor infraestructura.
  • Reducción de servicios.
  • Menos mantenimiento y seguridad.
  • Optimización inmobiliaria.

¿Estamos listos para una era de “transparencia financiera” en las contrataciones?

Conversaciones reales sobre eficiencia compartida.

El nuevo liderazgo: del control al acompañamiento estratégico

Mientras caminábamos hacia la sala de juntas, él comentó:
—A veces siento que debería supervisar más de cerca para asegurar resultados.
Le respondí:
—Supervisar no es liderar. Acompañar es lo que transforma equipos.

El liderazgo moderno ya no se basa en controlar tareas, sino en desbloquear capacidades.

Puntos clave

Liderazgo basado en control:

  • Genera dependencia.
  • Reduce autonomía.
  • Limita la innovación.

Liderazgo basado en acompañamiento:

  • Alinea visión.
  • Desbloquea capacidades.
  • Fomenta la responsabilidad.

¿Estamos formando líderes que acompañan o líderes que supervisan?

El liderazgo moderno no controla: acompaña.

La economía del talento: por qué las nuevas generaciones negocian diferente

En un coworking, mientras revisábamos una propuesta de contratación, él dijo:
—Los candidatos jóvenes preguntan cosas que antes nadie preguntaba.
Le respondí:
—No negocian beneficios. Negocian valor.

Las nuevas generaciones no buscan estabilidad por sí misma; buscan propósito, eficiencia y claridad.

Puntos clave

Lo que buscan:

  • Transparencia.
  • Flexibilidad basada en resultados.
  • Cultura auténtica

Lo que ya no aceptan:.

  • Ambigüedad.
  • Jerarquías rígidas.
  • Procesos lentos.

¿Estamos adaptando nuestras propuestas de valor al talento que queremos atraer?

El talento moderno busca valor real.

La cultura organizacional como ventaja competitiva medible

En la sala de juntas, él observó un dashboard y comentó:
—Nunca pensé que la cultura pudiera medirse.
Le respondí:
—Todo lo que impacta resultados puede medirse.

La cultura es un sistema operativo. Cuando se mide, se gestiona. Cuando se gestiona, se convierte en ventaja competitiva.

Puntos clave

Indicadores de cultura:

  • Velocidad de respuesta.
  • Rotación voluntaria.
  • Colaboración interáreas.

¿Estamos midiendo la cultura con la misma rigurosidad que medimos la operación?

La cultura define la velocidad de una organización.

El costo oculto de la ineficiencia operativa

Mientras revisábamos un flujo de procesos, él dijo:
—No entiendo cómo algo tan pequeño puede afectar tanto.
Le respondí:
—Las fugas pequeñas destruyen márgenes grandes.

La mayoría de las organizaciones no fracasan por grandes errores, sino por pequeñas ineficiencias acumuladas.

Puntos clave

Fugas comunes:

  • Reuniones sin propósito.
  • Procesos duplicados.
  • Falta de ownership.

¿Estamos midiendo el costo real de la ineficiencia?

La eficiencia es una ventaja competitiva.

El rol del mentor moderno en la empresa híbrida

Al salir de una reunión, él comentó:
—A veces siento que debería tener todas las respuestas.
Le respondí:
—Tu responsabilidad no es tener todas las respuestas. Es diseñar el sistema para que las respuestas emerjan rápido, con datos y sin fricción.

El mentor moderno no forma seguidores; forma líderes.

Puntos clave

El mentor moderno:

  • Escucha.
  • Formula preguntas.
  • Comparte contexto.
  • Desarrolla criterio.

¿Estamos formando líderes que dependen de respuestas o líderes capaces de generarlas?

Cierre.

El liderazgo moderno no se trata de controlar, sino de acompañar.
No se trata de imponer, sino de generar claridad.
No se trata de tener todas las respuestas, sino de construir criterio.

La eficiencia, la cultura y el talento no son temas aislados: son piezas de una misma conversación.
Y es en esas conversaciones —breves, reales, estratégicas— donde se forman los líderes que transforman organizaciones.

Herramienta Python para unir PDFs en páginas personalizadas

Herramienta Python para unir PDFs en páginas personalizadas

El tiempo es nuestro recurso más valioso, y a menudo lo perdemos en procesos que parecen sencillos pero terminan siendo ‘ladrones de tiempo’.

Con el uso de tecnologías como Python y la colaboración en ‘aldeas digitales’ como GitHub, podemos mejorar en conjunto y enfocarnos en ser verdaderamente productivos, eficientes y eficaces.

A continuación, comparto una solución a una necesidad real que viví hace unos días: un script que combina múltiples archivos PDF en una sola página (2×2, 3×2, etc.) con guías de corte automáticas. Es ideal para optimizar la impresión de credenciales, carnets de seguros o reportes médicos.

El proyecto completo se encuentra documentado aquí: 👉 https://github.com/aletorro/pdf-grid-processor.git

¿Qué proceso sencillo has automatizado hoy para ganar más tiempo?

🚀 Características de la solución:

  • Aplanamiento por imagen. Convierte cada PDF a imagen para eliminar errores de capas, metadatos y traslapes de texto.
  • Guías de corte. Genera bordes automáticos (gris tenue) que facilitan el recorte y doblado manual preciso.
  • Procesamiento masivo. Capacidad de escanear carpetas completas y generar automáticamente múltiples páginas de salida.

Requisitos:

  • Python 3.x
  • Bibliotecas: pdf2imagePillow
  • Poppler: Necesario para la conversión de PDF a imagen en Windows.

Instalación y Uso:

1. Instala las dependencias: pip install pdf2image pillow

2. Descarga los binarios de Poppler y ajusta la ruta PATH_POPPLER en el código.

3. Ejecuta el script apuntando a tu carpeta de documentos.

Código:
from pdf2image import convert_from_path
from PIL import Image, ImageDraw
import os
import math
def procesar_carpeta_pdf(carpeta_origen, archivo_salida, filas=2, columnas=2):
# Configuración de página Carta a 300 DPI
ANCHO_CARTA, ALTO_CARTA = 2550, 3300
ANCHO_CUAD = ANCHO_CARTA // columnas
ALTO_CUAD = ALTO_CARTA // filas
PATH_POPPLER = r"C:\poppler\Library\bin"
# Obtener lista de PDFs en la carpeta
archivos = [os.path.join(carpeta_origen, f) for f in os.listdir(carpeta_origen) if f.lower().endswith('.pdf')]
archivos.sort() # Ordenar alfabéticamente
if not archivos:
print("No se encontraron archivos PDF en la carpeta.")
return
paginas_finales = []
num_por_pagina = filas * columnas
total_paginas_necesarias = math.ceil(len(archivos) / num_por_pagina)
for p in range(total_paginas_necesarias):
# Crear lienzo nuevo para cada página de salida
lienzo = Image.new('RGB', (ANCHO_CARTA, ALTO_CARTA), (255, 255, 255))
dibujo = ImageDraw.Draw(lienzo)
# Seleccionar el grupo de archivos para esta página
inicio = p * num_por_pagina
fin = inicio + num_por_pagina
grupo_archivos = archivos[inicio:fin]
for idx, ruta in enumerate(grupo_archivos):
try:
# Calcular posición en la cuadrícula
fila_actual = idx // columnas
col_actual = idx % columnas
x_base = col_actual * ANCHO_CUAD
y_base = fila_actual * ALTO_CUAD
# --- DIBUJAR BORDE DE CORTE ---
# Dibujamos un rectángulo gris claro alrededor del cuadrante
dibujo.rectangle(
[x_base, y_base, x_base + ANCHO_CUAD, y_base + ALTO_CUAD],
outline=(200, 200, 200), width=3
)
# Procesar PDF a Imagen
imgs_pdf = convert_from_path(ruta, dpi=200, poppler_path=PATH_POPPLER)
img = imgs_pdf[0]
# Ajustar tamaño (dejando un pequeño margen interno para que el borde no toque el contenido)
img.thumbnail((ANCHO_CUAD - 40, ALTO_CUAD - 40), Image.Resampling.LANCZOS)
# Centrar y pegar
pos_x = x_base + (ANCHO_CUAD - img.width) // 2
pos_y = y_base + (ALTO_CUAD - img.height) // 2
lienzo.paste(img, (pos_x, pos_y))
except Exception as e:
print(f"Error en {ruta}: {e}")
paginas_finales.append(lienzo)
print(f"Página {p + 1} de {total_paginas_necesarias} preparada...")
# Guardar todo en un solo PDF multi-página
if paginas_finales:
paginas_finales[0].save(
archivo_salida, "PDF", resolution=300.0,
save_all=True, append_images=paginas_finales[1:]
)
print(f"\n✅ ¡LISTO! Se procesaron {len(archivos)} archivos en {len(paginas_finales)} páginas.")
# --- CONFIGURACIÓN DE TU CARPETA ---
# 1. Pon tus 36 PDFs en una carpeta (ej: 'mis_documentos')
# 2. Define cuántos quieres por página (ej: filas=3, columnas=2 para tener 6)
procesar_carpeta_pdf(
carpeta_origen="C:/PDFs_A_Combinar",
archivo_salida="Reporte_Masivo_Con_Bordes.pdf",
filas=2,
columnas=2
)
# Aquí podrian ponerse input's para los cuatro parámetros y sería más amigable,
# dejo a los amables lectores esa tarea y que nos comenten como les fue,
# y si les ha sido de utilidad

How to be plastic neutral?

How to be plastic neutral?

La Economía Circular es el futuro, asi de simple!

Avatar de SamayoaValienteSamayoa Valiente

A veces una idea sencilla toma fuerza y se convierte en una gran solución. La carbono neutralidad ha pasado ya por sus ires y venires, el protocolo de Kyoto fue un punto de partida para saber contar los gases de efecto invernadero (GEI) y Paris nos proponía una forma de fijar límites planetarios. Todavía hay un mundo que recorrer en la carbononeutralidad, pero el mundo avanza.

Ahora en la crisis actual relacionada el mundo del plástico en los océanos surge una alternativa que parece tiene todas las posibilidades de ser ganadora. Ser plástico neutral. Esto significa que de alguna manera compensar (offset) de tu huella plástica.

Hay un cambio de actitud, por ejemplo, el impacto del plástico oceánico se vería significativamente mermado sí los usuarios de los materiales los depositaran en el lugar correcto. Tendríamos un cambio significativo sí los encargado de la gestión de residuos tuvieran infraestructura adecuada. Pero…

Ver la entrada original 101 palabras más

Un proyecto introduce cambios: PRINCE2

Dos conceptos revisitados por Prince2:
1. Proyecto: organización temporal creada para entregar productos de negocio de acuerdo a los casos de negocios acordados.
2. Caso de negocio, debe incluir la siguiente información: la razón del proyecto, los beneficios, los costos, información del tiempo y el ROI.

Avatar de Pili GarcíaThe Manager Way

Buenas noches hoy les voy a comentar un poco acerca de la metodología para la gestión de Proyectos PRINCE2.

Prince2 es una metodología usada en la mayor parte de Europa, Australia, África y Canadá. Entre las empresas más conocidas que usan esta metodología podemos encontrar a IBM, Microsoft, DHL, Sun Microsistems, Shell, Virgin, British Airways, entre otras.

Organizaciones Mundiales como la ONU, el Banco Mundial e ILO (International Labour Organization)

Los 4 Elementos del Prince2:

Elementos del Prince2

Ver la entrada original 119 palabras más

ISO 9001:2015. ENFOQUE BASADO EN PROCESOS

La comprension y correcta aplicación de los Mapas de Flujo del Valor se vuelven cada vez más importantes para gestionar de forma efectiva! ISO 9001-2015

Avatar de Ing. Hugo GonzalezCalidad & Gestion - Consultoría para Empresas

ISO 9001:2015. ENFOQUE BASADO EN PROCESOS

En la nueva versión de la Norma ISO 9001:2015 se destaca la intención de enfatizar y guiar el Enfoque en Procesos. Dicho concepto fue introducido en la versión 2000 como uno de los principios de la gestión.

Ahora la nueva versión lo incluye a nivel de requisito y especifica elementos mínimos para su aplicación, asemejándose de esta manera al proceso HACCP.

NUEVA ISO 9001:2015 - ENFOQUE EN PROCESOS NUEVA ISO 9001:2015 – ENFOQUE EN PROCESOS

De acuerdo al borrador dado a conocer hasta el momento, y que se espera no resulte muy distinto de la versión que se publicará en septiembre de 2015, la Norma ISO 9001:2015 en el Capítulo 4.4 “Sistema de Gestión de la Calidad y sus procesos”especifica los requisitos esenciales para comprender plenamente el Enfoque en Procesos.

De este modo, se indica que la organización deberá determinar:

  • Los insumos necesarios y los resultados esperados de estos…

Ver la entrada original 2.514 palabras más