forked from nique_372/MQLArticles
#+------------------------------------------------------------------+
| |
#| App.py |
| |
#| Copyright 2026, Niquel Mendoza. |
| |
#| https://www.mql5.com |
| |
#+------------------------------------------------------------------+
| |
| |
#+------------------------------------------------------------------+
| |
#| Imports |
| |
#+------------------------------------------------------------------+
| |
import json
| |
import os
| |
import sys
| |
from tsn_utils import CLoggerBase
| |
from Base.Common import *
| |
| |
#+------------------------------------------------------------------+
| |
#| Notas de diseno |
| |
#+------------------------------------------------------------------+
| |
# Flujo: config.json -> prologo de cada archivo (main_file, pool_file opcional)
| |
# indicators.json -> ParseIndicators (UNA sola pasada, valida todo) -> lista de CIndSpec
| |
# EmitMain / EmitPool recorren la lista sin volver a comprobar nada.
| |
#
| |
# Validaciones: solo las que el compilador de mql5 NO da (campos faltantes, duplicados de class_name/prefix,
| |
# y el tipo de cada parametro para saber como escribirlo en la key del pool).
| |
# NO se validan identificadores (class_name, creator, nombres/tipos de parametros): se pegan tal cual
| |
# y si estan mal lo dice el compilador de mql5.
| |
#
| |
# Escapes: los includes se escapan (\ => \\) porque json los des-escapa y mql5 los necesita.
| |
# El campo "resource" NO se escapa: se escribe tal cual, si lleva "\" o '"' hay que ponerlo ya escapado en el json
| |
# (ej. "::Shared Projects\\\\X.ex5"). Cambiarlo cuando haga falta.
| |
#
| |
# Pool: el campo "prefix" de cada indicador se usa para Get<prefix> / Remove<prefix> y como key (string)
| |
# dentro del pool; el miembro es s_<prefix en snake_case> (SuperTrend => s_super_trend). Por eso se escribe
| |
# en CamelCase igual que el nombre que se quiere en la API (GetSuperTrend, GetStdDev, GetAdxWilder...).
| |
| |
| |
| |
| |
#+------------------------------------------------------------------+
| |
#| Clase principal |
| |
#+------------------------------------------------------------------+
| |
class CApp(CLoggerBase):
| |
| |
def __init__(self):
| |
super().__init__()
| |
| |
self.m_fn_src_file_ind = "" # archivo de config de indicadores (json)
| |
self.m_main = COutFile() # Main.mqh (clases de los indicadores)
| |
self.m_pool = None # Pool.mqh (opcional: solo si config tiene pool_file)
| |
| |
#+------------------------------------------------------------------+
| |
#| Utilidades de archivos |
| |
#+------------------------------------------------------------------+
| |
def LoadJson(self, file : str) -> dict | None:
| |
try:
| |
with open(file, "r", encoding="utf-8-sig") as f:
| |
return json.load(f)
| |
except (OSError, json.JSONDecodeError) as e:
| |
self.LogError(f"Fallo al leer/parsear json:\nFile: '{file}'\n{e}")
| |
return None
| |
| |
def SaveFile(self, out : COutFile) -> bool:
| |
try:
| |
with open(out.m_path, "w", encoding="utf-8", newline="") as f:
| |
f.write("".join(out.m_buf))
| |
return True
| |
except OSError as e:
| |
self.LogCriticalError(f"Failed to create file:\n'{out.m_path}'\n{e}")
| |
return False
| |
| |
#+------------------------------------------------------------------+
| |
#| Utilidades de escritura |
| |
#+------------------------------------------------------------------+
| |
# Linea con texto dentro del header de comentarios (trunca al espacio util)
| |
@staticmethod
| |
def LineWC(text : str) -> str:
| |
return TPL_LINEW.format(text=text[:SCRIPT_LINEW_PURESIZE])
| |
| |
# Bloque con titulo //+---+ //| titulo | //+---+
| |
@staticmethod
| |
def BlockWC(text : str) -> str:
| |
return TPL_LINE + SCRIPT_EOL + CApp.LineWC(text) + SCRIPT_EOL + TPL_LINE + SCRIPT_EOL
| |
| |
#+------------------------------------------------------------------+
| |
#| Run |
| |
#+------------------------------------------------------------------+
| |
def Run(self, fn_config : str) -> bool:
| |
#--- Parseamos la configuracion
| |
config = self.LoadJson(fn_config)
| |
if config is None or not self.ProccesConfig(config):
| |
return False
| |
| |
#--- Parseamos ahora si el archivo de indicadores (una sola pasada)
| |
inds = self.LoadJson(self.m_fn_src_file_ind)
| |
if inds is None:
| |
return False
| |
specs: list[CIndSpec] = self.ParseIndicators(inds, need_prefix=self.m_pool is not None)
| |
if specs is None:
| |
return False
| |
| |
#--- Generamos
| |
self.EmitMain(specs)
| |
if self.m_pool is not None and not self.EmitPool(specs):
| |
return False
| |
| |
#--- Guardamos los archivos finales
| |
for out in (self.m_main, self.m_pool):
| |
if out is not None and not self.SaveFile(out):
| |
return False
| |
| |
self.LogInfo("Se termino")
| |
return True
| |
| |
#+------------------------------------------------------------------+
| |
#| Config |
| |
#+------------------------------------------------------------------+
| |
def ProccesConfig(self, root : dict) -> bool:
| |
self.m_fn_src_file_ind = root.get("src_inds_file", "")
| |
if not isinstance(self.m_fn_src_file_ind, str) or not self.m_fn_src_file_ind:
| |
self.LogError("Falta el campo 'src_inds_file' que indica el archivo donde estan los indicadores, o esta malformado")
| |
return False
| |
| |
if not self.FileProrrogo(self.m_main, root.get("main_file", {})):
| |
return False
| |
| |
#--- Pool (opcional)
| |
if "pool_file" in root:
| |
self.m_pool = COutFile()
| |
return self.FileProrrogo(self.m_pool, root["pool_file"])
| |
return True
| |
| |
#+------------------------------------------------------------------+
| |
#| Prologo (header + props + guard + includes + namespace) |
| |
#+------------------------------------------------------------------+
| |
def FileProrrogo(self, out : COutFile, file : dict) -> bool:
| |
#--- Campos obligatorios
| |
out.m_path = file.get("path", "")
| |
if not out.m_path:
| |
self.LogError("No se pudo obtener el campo path")
| |
return False
| |
| |
pure = os.path.basename(out.m_path) # nombre puro del archivo
| |
autor = file.get("autor", "")
| |
link = file.get("link", "")
| |
for name, val in (("autor", autor), ("link", link)):
| |
if not val:
| |
self.LogError(f"Falta el campo {name} en file = '{pure}'")
| |
return False
| |
| |
#--- Header + props
| |
out.Add(TPL_HEADER.format(line=TPL_LINE, file=self.LineWC(pure),
| |
autor=self.LineWC(autor), link=self.LineWC(link),
| |
autor_raw=autor, link_raw=link))
| |
| |
#--- Guard (trunca a 256)
| |
out.m_guard = file.get("guard", "")[:SCRIPT_MAX_GUARD]
| |
if out.m_guard:
| |
out.Add(TPL_GUARD_INIT.format(guard=out.m_guard))
| |
| |
out.Add(TPL_BLOCK)
| |
| |
#--- Includes
| |
for i, include in enumerate(file.get("includes", [])):
| |
if "relative" in include:
| |
path, op, cl = include["relative"], '"', '"'
| |
elif "mql5" in include:
| |
path, op, cl = include["mql5"], "<", ">"
| |
else:
| |
self.LogError(f"includes[{i}]: solo se permite dos tipos [relative, mql5] nada mas")
| |
return False
| |
path = path[:SCRIPT_MAX_INCLUDE].replace("\\", "\\\\") # json lo des-escapa, mql5 lo necesita
| |
out.Add(TPL_INCLUDE.format(open=op, path=path, close=cl))
| |
| |
out.Add("\n")
| |
| |
#--- Namepsace
| |
out.m_namespace = file.get("namespace", "")
| |
if out.m_namespace:
| |
out.Add(TPL_BLOCK) # bloque
| |
out.Add(f"namespace {out.m_namespace}\n{{\n")
| |
| |
# Final
| |
self.LogInfo(f"Archivo = '{pure}' procesado correctamente")
| |
return True
| |
| |
#+------------------------------------------------------------------+
| |
#| Epilogo (fin del namespace + fin del guard) |
| |
#+------------------------------------------------------------------+
| |
def FileEpilogue(self, out : COutFile) -> None:
| |
if out.m_namespace:
| |
out.Add("//---\n}\n")
| |
if out.m_guard:
| |
out.Add(TPL_GUARD_END.format(guard=out.m_guard))
| |
| |
#+------------------------------------------------------------------+
| |
#| Pool: como se escribe un parametro en la key |
| |
#+------------------------------------------------------------------+
| |
@staticmethod
| |
def PoolWriter(tipo : str) -> str | None:
| |
w = POOL_WRITERS.get(tipo)
| |
if w is None and (tipo.startswith("ENUM_")):
| |
w = POOL_WRITE_ENUM
| |
return w
| |
| |
#+------------------------------------------------------------------+
| |
#| Indicadores: parseo + validacion (una sola pasada) |
| |
#+------------------------------------------------------------------+
| |
def ParseIndicators(self, root : dict, need_prefix : bool) -> list[CIndSpec] | None:
| |
indicators = root.get("indicators")
| |
if indicators is None:
| |
self.LogError("No se encontro indicators en el root")
| |
return None
| |
| |
specs: list[CIndSpec] = []
| |
classes = set()
| |
prefixes = set()
| |
| |
for curr_el, ind in enumerate(indicators):
| |
#--- class_name
| |
class_name = ind.get("class_name")
| |
if not class_name:
| |
self.LogError(f"No se encontro el campo class_name en indicators[{curr_el}]")
| |
return None
| |
if class_name in classes:
| |
self.LogError(f"indicators[{curr_el}]: class_name = '{class_name}' repetido")
| |
return None
| |
classes.add(class_name)
| |
| |
#--- prefix (solo obligatorio si se genera el pool)
| |
prefix = ind.get("prefix", "")
| |
if need_prefix:
| |
if not prefix:
| |
self.LogError(f"indicators[{curr_el}], Clase = {class_name}: falta el campo prefix (el pool lo necesita)")
| |
return None
| |
if prefix in prefixes:
| |
self.LogError(f"indicators[{curr_el}], Clase = {class_name}: prefix = '{prefix}' repetido")
| |
return None
| |
prefixes.add(prefix)
| |
| |
#--- num_buffers
| |
num_buffers = ind.get("num_buffers", 0)
| |
if not isinstance(num_buffers, int) or num_buffers < 1:
| |
self.LogError(f"indicators[{curr_el}], Clase = {class_name}, proporciono un numero de buffers menor a 1")
| |
return None
| |
| |
#--- type: "$ENUM" (se copia sin $) o numero unsigned
| |
ind_type = ind.get("type")
| |
if isinstance(ind_type, str) and ind_type.startswith("$"):
| |
ind_type = ind_type[1:]
| |
elif not (isinstance(ind_type, int) and ind_type >= 0):
| |
self.LogError(f"indicators[{curr_el}]: no se encontro el campo 'type' o debe ser string (enum, empieza con $) o un numero unsigned valido")
| |
return None
| |
| |
#--- creator
| |
creator = ind.get("creator")
| |
if not isinstance(creator, str):
| |
self.LogError(f"indicator[{curr_el}][{class_name}]: no se encontro el campo creator o no es string")
| |
return None
| |
| |
#--- parameters { nombre : tipo }
| |
params = ind.get("parameters")
| |
if not isinstance(params, dict):
| |
self.LogError(f"Campo parameters no esta presente.. en pos = {curr_el}")
| |
return None
| |
if not all(isinstance(t, str) for t in params.values()):
| |
self.LogError(f"indicator[{curr_el}]: solo se permite strings como valores en parameters")
| |
return None
| |
| |
#--- Pool: el tipo de cada parametro debe tener forma de escribirse en la key
| |
if need_prefix:
| |
for n, t in params.items():
| |
if self.PoolWriter(t) is None:
| |
self.LogError(f"indicator[{curr_el}][{class_name}]: el parametro '{n}' tiene un tipo no soportado por el pool ('{t}'), "
| |
f"debe ser nativo o empezar con ENUM_ (o estar en POOL_EXTRA_ENUMS)")
| |
return None
| |
| |
#--- resource
| |
resource: str = ind.get("resource", "")
| |
if resource:
| |
resource = f", \"{resource}\""
| |
| |
specs.append(CIndSpec(class_name, prefix, num_buffers, ind_type, creator, resource, list(params.items())))
| |
| |
return specs
| |
| |
#+------------------------------------------------------------------+
| |
#| Main.mqh: clases de los indicadores |
| |
#+------------------------------------------------------------------+
| |
def EmitMain(self, specs : list[CIndSpec]) -> None:
| |
for s in specs:
| |
self.m_main.Add(TPL_BLOCK)
| |
self.m_main.Add(TPL_CLASS_IND.format(class_name=s.class_name, num_buffers=s.num_buffers, type=s.ind_type,
| |
creator=s.creator, resource=s.resource, firma=s.firma, valores=s.valores))
| |
self.FileEpilogue(self.m_main)
| |
| |
#+------------------------------------------------------------------+
| |
#| Pool.mqh: cache de indicadores |
| |
#+------------------------------------------------------------------+
| |
def EmitPool(self, specs : list[CIndSpec]) -> bool:
| |
pool = POOL_CLASS_NAME
| |
| |
#--- Clase
| |
self.m_pool.Add(self.BlockWC("Cache de indicadores"))
| |
self.m_pool.Add(TPL_POOL_CLASS_HEAD.format(pool=pool))
| |
for s in specs:
| |
self.m_pool.Add(TPL_POOL_MEMBER.format(class_name=s.class_name, prefix=s.prefix, m=s.member))
| |
self.m_pool.Add(TPL_POOL_CLASS_MID.format(pool=pool))
| |
for s in specs:
| |
self.m_pool.Add(TPL_POOL_DECL.format(class_name=s.class_name, prefix=s.prefix, m=s.member, firma=s.firma))
| |
self.m_pool.Add(TPL_POOL_CLASS_END)
| |
self.m_pool.Add("\n")
| |
| |
#--- Init + RemoveFromArray
| |
self.m_pool.Add(TPL_POOL_COMMON.format(pool=pool))
| |
| |
#--- Get* de cada indicador
| |
for s in specs:
| |
self.m_pool.Add(TPL_BLOCK)
| |
writes = "".join(f" s_bit.{self.PoolWriter(t).format(v=n)};\n" for n, t in s.params)
| |
self.m_pool.Add(TPL_POOL_GET.format(class_name=s.class_name, pool=pool, prefix=s.prefix, m=s.member,
| |
firma=s.firma, valores=s.valores, writes=writes))
| |
| |
#--- Deinit
| |
self.m_pool.Add(TPL_POOL_DEINIT_HEAD.format(pool=pool))
| |
for s in specs:
| |
self.m_pool.Add(TPL_POOL_DEINIT_ITEM.format(prefix=s.prefix, m=s.member))
| |
self.m_pool.Add(TPL_POOL_DEINIT_END.format())
| |
| |
#--- Variables estaticas
| |
self.m_pool.Add("\n")
| |
self.m_pool.Add(TPL_POOL_STATIC_HEAD.format(pool=pool))
| |
for s in specs:
| |
self.m_pool.Add(TPL_POOL_STATIC_ITEM.format(class_name=s.class_name, pool=pool, prefix=s.prefix, m=s.member))
| |
| |
self.FileEpilogue(self.m_pool)
| |
return True
| |
| |
#+------------------------------------------------------------------+
| |
#| Main |
| |
#+------------------------------------------------------------------+
| |
def Main() -> int:
| |
#--- Path completo al json de configuracion
| |
fn_config = sys.argv[1] if len(sys.argv) > 1 else \
| |
r"C:\Users\leoxd\AppData\Roaming\MetaQuotes\Terminal\D0E8209F77C8CF37AD8BF550E51FF075\MQL5\Shared Projects\MQLArticles\IndicatorsCts\Imp\Code\Config\config.json"
| |
| |
app = CApp()
| |
app.AddLogFlags(CLoggerBase.LOG_ALL)
| |
return 0 if app.Run(fn_config) else 1
| |
| |
if __name__ == "__main__":
| |
sys.exit(Main())
|