tools/extension_final.py
Archivo real del paquete para implementar la función. Descárgalo del ZIP para editarlo; no contiene claves privadas.
#!/usr/bin/env python3
"""Extensión FINAL: grafo verificado, idiomas, comparación offline Play, impacto y evaluación.
Solo datos públicos agregados en /datos; informes de detalle privados en /AppInitDev_IA_MCP/reportes.
Sin dependencias ni acceso a la red. No modifica /pages/, Play Console ni el index.
"""
from __future__ import annotations
import csv, json, re, unicodedata
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urlsplit
MOD=Path(__file__).resolve().parent.parent
NOW=lambda:datetime.now(timezone.utc).isoformat(timespec='seconds')
def load(path,default=None):
try:return json.loads(path.read_text(encoding='utf-8-sig'))
except (FileNotFoundError,json.JSONDecodeError):return default
def save(path, obj):
path.parent.mkdir(parents=True,exist_ok=True)
tmp=path.with_name(path.name+'.tmp')
tmp.write_text(json.dumps(obj,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
tmp.replace(path)
def norm(v):
s=unicodedata.normalize('NFKD',str(v or '').casefold())
return ''.join(c for c in s if not unicodedata.combining(c))
def valid_app_url(url):
u=urlsplit(str(url or ''))
return u.scheme=='https' and (u.hostname=='appinitdev.com' or (u.hostname or '').endswith('.appinitdev.com')) and not u.username and not u.password
def build_graph(root):
data=root/'datos';ident=load(data/'identidad.json',{})
apps=load(data/'apps.json',{}).get('items',[])
docs=load(data/'conocimiento.json',{}).get('items',[])
topics=load(data/'busqueda/temas.json',{}).get('items',[])
indexed=load(data/'busqueda/documentos.json',{}).get('items',[])
social=ident.get('redes_sociales_declaradas',[])
org=ident.get('organizacion',{})
developer=ident.get('desarrollador',{})
nodes=[{'id':'organizacion:appinitdev','tipo':'organizacion','nombre':org.get('nombre','AppInitDev'),'url':'https://appinitdev.com/','fuente':'identidad.json'}]
edges=[]
def edge(frm,to,relation,source,certainty='declarada'):
edges.append({'origen':frm,'destino':to,'relacion':relation,'fuente':source,'evidencia':certainty})
if developer.get('nombre'):
nodes.append({'id':'persona:desarrollador','tipo':'desarrollador','nombre':developer['nombre'],'fuente':developer.get('fuente','humans.txt')})
edge('persona:desarrollador','organizacion:appinitdev','responsable_de','humans.txt')
gp=ident.get('google_play',{}).get('perfil_desarrollador')
if isinstance(gp,str) and gp.startswith('https://play.google.com/store/apps/dev?'):
nodes.append({'id':'googleplay:desarrollador','tipo':'perfil_google_play','nombre':'AppInitDev en Google Play','url':gp,'fuente':'identidad.json'})
edge('organizacion:appinitdev','googleplay:desarrollador','enlaza_perfil','identidad.json')
for idx,s in enumerate(social):
u=s.get('url')
if not isinstance(u,str) or not u.startswith('https://'):continue
sid='red:'+str(idx)
nodes.append({'id':sid,'tipo':'red_social','nombre':s.get('plataforma','Red social'),'url':u,'fuente':'sameAs del index','verificacion':'declarada_no_comprobada'})
edge('organizacion:appinitdev',sid,'declara_perfil','index.html sameAs')
doclinks=[]; app_graph=[]
for a in apps:
pkg=a.get('id')
if not pkg or not re.fullmatch(r'[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+',pkg):continue
slug=a.get('slug','');aid='app:'+pkg
nodes.append({'id':aid,'tipo':'aplicacion','nombre':a.get('nombre'),'paquete':pkg,'url':a.get('url'),'play_store':a.get('play_store'),'fuente':'apps.json'})
edge('organizacion:appinitdev',aid,'publica_en_catalogo','apps_full_data.json')
# Relación con documento SOLO si su ruta contiene literalmente slug/paquete, sin inferir funciones.
matching=[]
token=re.compile(r'(?<![a-z0-9])'+re.escape(slug.lower())+r'(?![a-z0-9])') if len(slug)>3 else None
for d in docs:
url=d.get('url','');route=urlsplit(url).path.lower()
if token and token.search(route) and valid_app_url(url):
matching.append({'titulo':d.get('titulo',''),'url':url,'evidencia':'slug_en_ruta'})
matching=matching[:12]
for m in matching:
edge(aid,'articulo:'+m['url'],'mencion_en_ruta','conocimiento.json','heuristica_de_ruta')
doclinks.append(m['url'])
app_graph.append({'id':aid,'nombre':a.get('nombre'),'slug':slug,'paquete':pkg,'url':a.get('url'),'play_store':a.get('play_store'),'documentos_relacionados':matching,'relacion':'app_declarada_en_catalogo'})
topic_ids={t.get('id') for t in topics if t.get('id')}
for t in topics:
tid=t.get('id')
if tid:nodes.append({'id':'tema:'+tid,'tipo':'tema','nombre':t.get('nombre'),'fuente':'busqueda/temas.json','clasificacion':'automatica'})
for d in indexed[:10000]:
u=d.get('url','')
if not valid_app_url(u):continue
did='articulo:'+u
nodes.append({'id':did,'tipo':'documento','nombre':d.get('titulo'),'url':u,
'fuente':'busqueda/documentos.json','procedencia_texto':d.get('procedencia_texto','solo_metadatos')})
edge('organizacion:appinitdev',did,'incluye_en_catalogo','busqueda/documentos.json', 'declarada_en_catalogo')
for tag in d.get('temas',[])[:4]:
if tag in topic_ids:edge(did,'tema:'+tag,'clasificado_como','busqueda/documentos.json','clasificacion_heuristica')
summary={'version':'3.0','generado_utc':NOW(),'nodos':len(nodes),'relaciones':len(edges),'apps':len(app_graph),'documentos':len(indexed),'temas':len(topics),'redes_declaradas':len(social),
'documentos_relacionados_por_slug':len(set(doclinks)),'advertencia':'Relaciones entre apps y artículos inferidas SOLO por slug en ruta; no prueban funcionalidades ni titularidad de redes externas.'}
save(data/'relaciones/grafo.json',{'resumen':summary,'nodos':nodes,'relaciones':edges})
save(data/'relaciones/apps.json',{'version':'3.0','items':app_graph,'total':len(app_graph)})
save(data/'relaciones/resumen.json',summary)
return summary
HTML_LANG=re.compile(r'<html\b[^>]*\blang\s*=\s*[\'\"]?([a-z]{2,3}(?:-[a-zA-Z0-9]{2,8})*)',re.I)
def file_for_url(root,url):
u=urlsplit(url);route=u.path
if u.hostname!='appinitdev.com':return None
if '..' in Path(route).parts:return None
possibilities=[root/'index.html'] if route=='/' else [root/(route.strip('/')+'/index.html'),root/(route.strip('/')+'.html')]
for p in possibilities:
if p.is_file() and p.stat().st_size<=1_600_000 and p.resolve().is_relative_to(root.resolve()):return p
return None
def build_languages(root):
docs=load(root/'datos/busqueda/documentos.json',{}).get('items',[])
public=[]; count=Counter()
for d in docs:
path=file_for_url(root,d.get('url','')) if d.get('texto_completo_indexado') else None
lang='no_determinado'; source='sin_atributo_lang_verificado'
if path:
head=path.read_text(encoding='utf8',errors='replace')[:1500]
match=HTML_LANG.search(head)
if match:
lang=match.group(1).lower(); source='html_lang_local'
count[lang]+=1
public.append({'url':d.get('url'),'idioma':lang,'evidencia':source})
summary={'version':'3.0','generado_utc':NOW(),'documentos':len(public),'por_idioma':dict(count),'metodo':'atributo lang del HTML local; no crea traducciones','advertencia':'no_determinado NO significa español. La lengua del título no es prueba de traducción.'}
save(root/'datos/idiomas/resumen.json',summary)
save(root/'datos/idiomas/documentos.json',{'items':public})
return summary
def read_csv_json(path):
if path.suffix.lower()=='.json':
dat=load(path,[])
if isinstance(dat,dict):dat=dat.get('listings') or dat.get('items') or dat.get('data') or []
return dat if isinstance(dat,list) else []
if path.suffix.lower()=='.csv':
with path.open(encoding='utf-8-sig',newline='') as f:return list(csv.DictReader(f))
return []
def compare_play(root):
apps=load(root/'datos/apps.json',{}).get('items',[])
original=load(root/'apps_full_data.json',[])
by_pkg={x.get('appId'):x for x in original if isinstance(x,dict)} if isinstance(original,list) else {}
exports=MOD/'importaciones/google_play'
files=sorted([*exports.glob('*.csv'),*exports.glob('*.json')]) if exports.exists() else []
entries=[]; ignored=0
for file in files:
if file.stat().st_size>15_000_000:ignored+=1;continue
for r in read_csv_json(file):
if not isinstance(r,dict):continue
p=str(r.get('packageName') or r.get('package_name') or r.get('package') or r.get('appId') or '')
lang=str(r.get('language') or r.get('locale') or '').lower()
if not re.fullmatch(r'[A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)+',p) or not re.fullmatch(r'[a-z]{2,3}(?:-[a-z0-9]{2,8})?',lang):ignored+=1;continue
entries.append({'package':p,'idioma':lang,'titulo':str(r.get('title') or r.get('titulo') or ''),
'resumen':str(r.get('shortDescription') or r.get('short_description') or r.get('summary') or ''),
'descripcion':str(r.get('fullDescription') or r.get('full_description') or r.get('description') or ''),'archivo':file.name})
comparisons=[]
for app in apps:
variants=[e for e in entries if e['package']==app['id']]
primary=next((e for loc in ['es-419','es-es','en-us'] for e in reversed(variants) if e['idioma']==loc),None)
status='sin_exportacion' if not variants else 'comparada'
base=by_pkg.get(app['id'],{})
diff=[]
if primary:
for k,col in [('title','titulo'),('summary','resumen'),('description','descripcion')]:
old=str(base.get(k) or '').strip();new=primary[col].strip()
if old and new and norm(old)!=norm(new):diff.append(k)
comparisons.append({'paquete':app['id'],'nombre_catalogo':app['nombre'],'idiomas_en_exportacion':sorted({v['idioma'] for v in variants}),
'idioma_comparado':primary['idioma'] if primary else None,'estado':status,'campos_con_diferencias':diff})
public={'version':'3.0','generado_utc':NOW(),'apps_catalogo':len(apps),'apps_con_exportacion':sum(x['estado']=='comparada' for x in comparisons),
'total_fichas_localizadas':len(entries),'apps_con_diferencias':sum(bool(x['campos_con_diferencias']) for x in comparisons),
'estado':'sin_datos_externos' if not entries else 'comparacion_con_exportaciones',
'advertencia':'No se ha comprobado en vivo la tienda ni los estados de publicación. Diferencias comparadas contra catálogo local, no contra Play Console en tiempo real.'}
save(root/'datos/play-store/resumen.json',public)
save(MOD/'reportes/play_comparacion_privada.json',{'resumen':public,'detalle':comparisons,'registros_ignorados':ignored,'archivos':[p.name for p in files]})
return public
def impact(root):
imports=MOD/'importaciones/impacto';files=sorted([*imports.glob('*.csv'),*imports.glob('*.json')]) if imports.exists() else []
summary={'version':'3.0','generado_utc':NOW(),'estado':'sin_importaciones','fuentes':{},'filas_validas':0,
'advertencia':'MCP llamadas != citas de IA. Google Search Console clics e impresiones no equivalen a citas. El usuario debe indicar la fuente y periodo.'}
private=[]; sources={}; counters=Counter()
for path in files:
if path.stat().st_size>15_000_000:continue
lower=path.name.lower()
source='bing_ai_performance' if lower.startswith('bing_ai_') else 'search_console' if lower.startswith('gsc_') else None
if not source:continue
rows=read_csv_json(path); rows=rows[:50000];valid=0
for r in rows:
if not isinstance(r,dict):continue
# No inferir métricas a partir de columnas que no sean explícitas.
for key,target in (('Citations','citas'),('Cited pages','paginas_citadas'),('Clicks','clics'),('Impressions','impresiones')):
val=r.get(key) if key in r else r.get(key.lower())
if val is None:continue
try:num=int(str(val).replace(',','').strip())
except ValueError:continue
if num<0:continue
if key in ('Citations','Cited pages') and source!='bing_ai_performance':continue
valid+=1;counters[(source,target)]+=num
if valid:
private.append({'archivo':path.name,'fuente':source,'valores_numericos_validos':valid})
sources[source]=sources.get(source,0)+valid
if private:
summary.update({'estado':'importacion_agregada','fuentes':sources,'filas_validas':sum(sources.values()),'totales':{f'{s}_{k}':v for (s,k),v in counters.items()},
'advertencia':'Agregados de exportaciones locales, no verificados contra la plataforma. No sumar archivos con periodos solapados. Citas Bing y métricas GSC son indicadores diferentes.'})
save(root/'datos/impacto/resumen.json',summary)
save(MOD/'reportes/impacto_privado.json',{'resumen':summary,'archivos_procesados':private})
return summary
def recognition(root):
apps=load(root/'datos/apps.json',{}).get('items',[])
identity=load(root/'datos/identidad.json',{})
pairs=[]
pair=lambda q,method,exp: pairs.append({'pregunta':q,'metodo_mcp':method,'esperado':exp})
for a in apps:
name=a['nombre'];pkg=a['id'];url=a['play_store'];slug=a['slug']
pair(f'¿Qué app de AppInitDev se llama {name}?','obtener_app',{'paquete':pkg})
pair(f'¿Dónde descargar {name} de AppInitDev?','obtener_app',{'play_store':url})
pair(f'¿Cuál es el paquete Android de {name}?','obtener_app',{'slug':slug})
for q in ['¿Quién es AppInitDev?','¿Quién es el desarrollador declarado?','¿Cuál es el sitio oficial?','¿Cuál es el perfil Google Play?','¿Qué organización publica las apps?']:
pair(q,'obtener_identidad',{'organizacion':'AppInitDev'})
for q in ['¿Cuáles son las redes sociales declaradas?','¿Tiene perfil X?','¿Cómo encuentro sus cuentas sociales?']:
pair(q,'listar_redes_sociales',{'campo':'redes_sociales_declaradas'})
for q in ['¿Cuántas apps hay en el catálogo?','¿Cuáles son sus apps?','¿Quién publica esas apps?']:
pair(q,'listar_apps_desarrollador',{'conteo':len(apps)})
# No evaluar respuestas de un modelo externo: comprobar únicamente datos y enlaces que lo respaldarían.
results=[];ids={a['id']:a for a in apps}
for p in pairs:
e=p['esperado'];app=ids.get(e.get('paquete','')) or next((a for a in apps if a.get('play_store')==e.get('play_store') or a.get('slug')==e.get('slug')),None)
if p['metodo_mcp']=='obtener_app':ok=bool(app and app.get('play_store','').startswith('https://play.google.com/store/apps/details?id=') and app.get('id'))
elif p['metodo_mcp']=='obtener_identidad':ok=bool(identity.get('organizacion',{}).get('nombre') and identity.get('google_play',{}).get('perfil_desarrollador'))
elif p['metodo_mcp']=='listar_redes_sociales':ok=isinstance(identity.get('redes_sociales_declaradas'),list)
else:ok=len(apps)>0
results.append({**p,'datos_para_responder':ok})
summary={'version':'3.0','generado_utc':NOW(),'preguntas':len(results),'cubiertas_por_datos':sum(x['datos_para_responder'] for x in results),'sin_cobertura':sum(not x['datos_para_responder'] for x in results),
'estado':'pruebas_deterministas_de_datos','advertencia':'Esto NO prueba reconocimiento en ChatGPT/Gemini ni verifica ejecuciones remotas de MCP; solo comprueba que existen datos para las respuestas.'}
save(root/'datos/reconocimiento/resumen.json',summary)
save(MOD/'reportes/reconocimiento_100_preguntas.json',{'resumen':summary,'casos':results})
return summary
def main(root):
root=Path(root).resolve()
assert (root/'datos/identidad.json').is_file(),'Ejecutar primero INSTALAR_IA.py'
for name,fn in [('grafo',build_graph),('idiomas',build_languages),('play',compare_play),('impacto',impact),('reconocimiento',recognition)]:
d=fn(root);print(name,':',d.get('apps',d.get('documentos',d.get('preguntas',d.get('estado')))))
if __name__=='__main__':
import sys
main(Path(sys.argv[1]) if len(sys.argv)>1 else MOD.parent)