aecode 0.2.0__py3-none-any.whl

aecode/__init__.py

@@ -0,0 +1,7 @@
+"""AeCode - DSL ultra-compacto para scraping, UI y APIs."""
+__version__ = "0.2.0"
+
+from .web_engine import ae_get, ae_select, ae_attr, ae_crawl, scrape
+from .ui_engine import build_ui, build_and_open
+from .flow_engine import run_flow
+from .api_engine import ae_api_get, ae_api_post, ae_api_graphql, run_api

aecode/api_engine.py

@@ -0,0 +1,161 @@
+import requests
+import json
+import re
+
+def _resolve_nested_key(data, key_path):
+    if not isinstance(data, dict):
+        return None
+    keys = key_path.strip().split('.')
+    curr = data
+    for k in keys:
+        if isinstance(curr, dict) and k in curr:
+            curr = curr[k]
+        elif isinstance(curr, list) and k.isdigit():
+            idx = int(k)
+            if 0 <= idx < len(curr):
+                curr = curr[idx]
+            else:
+                return None
+        else:
+            return None
+    return curr
+
+def ae_api_get(url, headers=None, params=None):
+    hdrs = {'User-Agent': 'AeCode/0.2.0'}
+    if headers:
+        hdrs.update(headers)
+    resp = requests.get(url, headers=hdrs, params=params, timeout=15)
+    resp.raise_for_status()
+    return resp.json()
+
+def ae_api_post(url, body=None, headers=None):
+    hdrs = {'User-Agent': 'AeCode/0.2.0', 'Content-Type': 'application/json'}
+    if headers:
+        hdrs.update(headers)
+    resp = requests.post(url, headers=hdrs, json=body or {}, timeout=15)
+    resp.raise_for_status()
+    return resp.json()
+
+def ae_api_graphql(url, query, variables=None, headers=None):
+    hdrs = {'User-Agent': 'AeCode/0.2.0', 'Content-Type': 'application/json'}
+    if headers:
+        hdrs.update(headers)
+    payload = {'query': query}
+    if variables:
+        payload['variables'] = variables
+    resp = requests.post(url, headers=hdrs, json=payload, timeout=15)
+    resp.raise_for_status()
+    return resp.json()
+
+def ae_api_select(data, fields):
+    if isinstance(data, list):
+        results = []
+        for item in data:
+            row = {}
+            for f in fields:
+                alias = f
+                key = f
+                if ' as ' in f.lower():
+                    parts = re.split(r'\s+as\s+', f, flags=re.IGNORECASE)
+                    key = parts[0].strip()
+                    alias = parts[1].strip()
+                row[alias] = _resolve_nested_key(item, key)
+            results.append(row)
+        return results
+    elif isinstance(data, dict):
+        row = {}
+        for f in fields:
+            alias = f
+            key = f
+            if ' as ' in f.lower():
+                parts = re.split(r'\s+as\s+', f, flags=re.IGNORECASE)
+                key = parts[0].strip()
+                alias = parts[1].strip()
+            row[alias] = _resolve_nested_key(data, key)
+        return row
+    return data
+
+def run_api(code):
+    """
+    Executes an AeAPI script.
+    Syntax:
+      DATA = GET "url" | SELECT field1, field2
+      DATA = POST "url" {"key": "val"} | SELECT ...
+      DATA = GRAPHQL "url" "query" | SELECT ...
+    """
+    env = {}
+    lines = [l.strip() for l in code.strip().split('\n') if l.strip() and not l.strip().startswith('//')]
+
+    for line in lines:
+        var_name = "RESULT"
+        pipeline = line
+        if '=' in line and not line.startswith('GET') and not line.startswith('POST') and not line.startswith('GRAPHQL'):
+            parts = line.split('=', 1)
+            var_name = parts[0].strip()
+            pipeline = parts[1].strip()
+
+        segments = [s.strip() for s in pipeline.split('|')]
+        source_segment = segments[0]
+        current_data = None
+
+        # 1. Source (GET, POST, GRAPHQL)
+        m_get = re.match(r'GET\s+"([^"]+)"(?:\s+(\{.*?\}))?', source_segment)
+        m_post = re.match(r'POST\s+"([^"]+)"(?:\s+(\{.*?\}))?', source_segment)
+        m_gql = re.match(r'GRAPHQL\s+"([^"]+)"\s+"([^"]+)"(?:\s+(\{.*?\}))?', source_segment)
+
+        if m_get:
+            url = m_get.group(1)
+            raw_headers = m_get.group(2)
+            headers = json.loads(raw_headers) if raw_headers else None
+            current_data = ae_api_get(url, headers=headers)
+        elif m_post:
+            url = m_post.group(1)
+            raw_body = m_post.group(2)
+            body = json.loads(raw_body) if raw_body else {}
+            current_data = ae_api_post(url, body=body)
+        elif m_gql:
+            url = m_gql.group(1)
+            query = m_gql.group(2)
+            raw_vars = m_gql.group(3)
+            variables = json.loads(raw_vars) if raw_vars else None
+            current_data = ae_api_graphql(url, query=query, variables=variables)
+
+        # 2. Pipeline processing (| SELECT ..., | filter(...))
+        for op in segments[1:]:
+            op = op.strip()
+            if op.startswith('SELECT'):
+                fields_str = op[len('SELECT'):].strip()
+                fields = [f.strip() for f in fields_str.split(',') if f.strip()]
+                current_data = ae_api_select(current_data, fields)
+            elif op.startswith('filter('):
+                m_filter = re.search(r'filter\((.*?)\)', op)
+                if m_filter and isinstance(current_data, list):
+                    expr = m_filter.group(1)
+                    # Simple filter like field > val or field == val
+                    m_cond = re.match(r'([a-zA-Z0-9_]+)\s*(==|!=|>|<|>=|<=)\s*(.*)', expr)
+                    if m_cond:
+                        f_name, op_sym, target_val = m_cond.groups()
+                        target_val = target_val.strip().strip('"').strip("'")
+                        try:
+                            target_val = float(target_val)
+                        except:
+                            pass
+                        
+                        def matches(item):
+                            val = item.get(f_name)
+                            if val is None:
+                                return False
+                            if op_sym == '==': return val == target_val
+                            if op_sym == '!=': return val != target_val
+                            if op_sym == '>': return val > target_val
+                            if op_sym == '<': return val < target_val
+                            if op_sym == '>=': return val >= target_val
+                            if op_sym == '<=': return val <= target_val
+                            return True
+                        
+                        current_data = [x for x in current_data if matches(x)]
+
+        env[var_name] = current_data
+        print(f"[{var_name}] => {json.dumps(current_data, indent=2, ensure_ascii=False)}")
+
+    return env

aecode/cli.py

@@ -0,0 +1,61 @@
+import click
+from pathlib import Path
+
+@click.group()
+@click.version_option(version="0.2.0")
+def main():
+    """AeCode - DSL ultra-compacto para scraping, UI y APIs."""
+    pass
+
+@main.command()
+@click.argument('archivo', type=click.Path(exists=True))
+def scrape(archivo):
+    """Ejecuta un archivo .ae de scraping (AeWeb)."""
+    from .web_engine import ae_get, ae_select, ae_attr
+    code = Path(archivo).read_text(encoding='utf-8')
+    click.echo(f"Ejecutando scraper: {archivo}")
+    click.echo(code)
+    click.echo("Scraper ejecutado.")
+
+@main.command()
+@click.argument('archivo', type=click.Path(exists=True))
+@click.option('--output', '-o', default='output.html', help='Archivo HTML de salida')
+def build(archivo, output):
+    """Compila un archivo .ae de UI a HTML (AeUI)."""
+    from .ui_engine import build_and_open
+    code = Path(archivo).read_text(encoding='utf-8')
+    click.echo(f"Compilando UI: {archivo}")
+    build_and_open(code, output)
+    click.echo(f"Listo: {output}")
+
+@main.command()
+@click.argument('archivo', type=click.Path(exists=True))
+def flow(archivo):
+    """Ejecuta un archivo .ae de flujo completo (Scrape + UI)."""
+    from .flow_engine import run_flow
+    code = Path(archivo).read_text(encoding='utf-8')
+    click.echo(f"Ejecutando flow: {archivo}")
+    run_flow(code)
+    click.echo("Flow completado.")
+
+@main.command()
+@click.argument('archivo', type=click.Path(exists=True))
+def api(archivo):
+    """Ejecuta un archivo .ae de consumo de APIs (AeAPI)."""
+    from .api_engine import run_api
+    code = Path(archivo).read_text(encoding='utf-8')
+    click.echo(f"Ejecutando API: {archivo}")
+    run_api(code)
+    click.echo("API completado.")
+
+@main.command()
+def doctor():
+    """Verifica dependencias instaladas."""
+    deps = ['requests', 'bs4', 'lark', 'click']
+    nombres = ['requests', 'beautifulsoup4', 'lark', 'click']
+    for dep, nombre in zip(deps, nombres):
+        try:
+            __import__(dep)
+            click.echo(f"  OK: {nombre}")
+        except ImportError:
+            click.echo(f"  FALTA: {nombre} (pip install {nombre})")

aecode/flow_engine.py

@@ -0,0 +1,138 @@
+import webbrowser
+import re
+from pathlib import Path
+from .web_engine import scrape
+from .ui_engine import build_ui
+
+def flow_scrape(url, item_selector, fields):
+    print(f"[AeFlow] Scraping {url}...")
+    results = scrape(url, item_selector, fields)
+    print(f"[AeFlow] {len(results)} items extraidos con éxito")
+    return results
+
+def flow_grid(data, cols, fields):
+    cols = int(cols)
+    if not data:
+        print("⚠️ [AeFlow] Advertencia: flow_grid recibió una lista vacía de datos.")
+        return '''<div class="max-w-7xl mx-auto px-6 py-12 text-center text-gray-400">
+  <p class="text-xl font-semibold mb-2">No se encontraron datos</p>
+  <p class="text-sm">Verifica la URL o los selectores CSS del paso SCRAPE.</p>
+</div>'''
+
+    cards_html = []
+    for idx, item in enumerate(data, 1):
+        title_val = item.get(fields[0], item.get('title', f"Item {idx}")) if fields else item.get('title', f"Item {idx}")
+        price_val = item.get(fields[1], item.get('price', "")) if fields and len(fields) > 1 else item.get('price', "")
+        
+        card = f'''      <div class="bg-gray-900 border border-gray-800 hover:border-amber-500/50 rounded-2xl p-5 shadow-xl transition-all duration-300 hover:-translate-y-2 flex flex-col justify-between group">
+        <div>
+          <div class="h-40 bg-gradient-to-tr from-amber-950/40 to-gray-800 rounded-xl mb-4 flex items-center justify-center text-amber-400 group-hover:scale-[1.02] transition-transform">
+            <svg class="w-12 h-12 opacity-80" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M12 6.253v13m0-13C10.832 5.477 9.246 5 7.5 5S4.168 5.477 3 6.253v13C4.168 18.477 5.754 18 7.5 18s3.332.477 4.5 1.253m0-13C13.168 5.477 14.754 5 16.5 5c1.747 0 3.332.477 4.5 1.253v13C19.832 18.477 18.247 18 16.5 18c-1.746 0-3.332.477-4.5 1.253"></path></svg>
+          </div>
+          <span class="text-xs font-semibold px-2.5 py-1 bg-amber-500/10 text-amber-400 rounded-full border border-amber-500/20 mb-2 inline-block">Item #{idx}</span>
+          <h3 class="text-lg font-bold text-white mb-2 line-clamp-2 leading-snug group-hover:text-amber-300 transition-colors" title="{title_val}">{title_val}</h3>
+        </div>
+        <div class="pt-3 border-t border-gray-800 flex items-center justify-between mt-3">
+          <span class="text-2xl font-black text-amber-400">{price_val}</span>
+          <button onclick="alert('Seleccionado: {title_val}')" class="px-4 py-2 bg-gradient-to-r from-amber-500 to-orange-600 hover:from-amber-400 hover:to-orange-500 text-gray-950 font-bold text-sm rounded-xl shadow-md transition transform active:scale-95 cursor-pointer">Ver</button>
+        </div>
+      </div>'''
+        cards_html.append(card)
+    
+    view_html = f'''<div class="max-w-7xl mx-auto px-6 py-8">
+    <div class="mb-8 pb-6 border-b border-gray-800 flex flex-col md:flex-row md:items-center justify-between gap-4">
+      <div>
+        <h2 class="text-3xl font-extrabold text-white">Catálogo de Libros en Vivo</h2>
+        <p class="text-gray-400 text-sm mt-1">{len(data)} items extraídos con éxito | AeFlow Engine</p>
+      </div>
+      <div>
+        <span class="px-4 py-2 bg-gray-900 border border-gray-800 text-amber-400 text-sm font-bold rounded-xl shadow-sm">
+          Total: {len(data)} items
+        </span>
+      </div>
+    </div>
+    <div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-{cols} gap-6">
+{''.join(cards_html)}
+    </div>
+  </div>'''
+    return view_html
+
+def flow_render(view_content, output="aeflow_result.html"):
+    if not view_content:
+        view_content = '<div class="p-12 text-center text-red-400 font-bold">Error: No hay contenido para renderizar en VIEW.</div>'
+
+    full_html = f"""<!DOCTYPE html>
+<html lang="es">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>AeFlow Dashboard</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;600;800;900&display=swap" rel="stylesheet">
+  <style>body {{ font-family: 'Plus Jakarta Sans', sans-serif; }}</style>
+</head>
+<body class="bg-gray-950 text-gray-100 min-h-screen">
+  <nav class="bg-gray-900 border-b border-gray-800 px-8 py-4 flex items-center justify-between sticky top-0 z-50 backdrop-blur bg-gray-900/90 shadow-md">
+    <div class="flex items-center gap-3">
+      <div class="w-8 h-8 rounded-lg bg-gradient-to-tr from-amber-500 to-orange-600 flex items-center justify-center font-black text-gray-950 text-lg">⚡</div>
+      <span class="font-extrabold text-xl text-white">Ae<span class="text-amber-400">Flow</span></span>
+    </div>
+    <span class="px-3 py-1 rounded-full bg-emerald-500/10 text-emerald-400 border border-emerald-500/20 text-xs font-semibold">● Live Scraped</span>
+  </nav>
+{view_content}
+  <footer class="text-center py-8 text-gray-600 border-t border-gray-900 text-sm mt-12">Generado automáticamente por AeCode Engine</footer>
+</body>
+</html>"""
+    out_path = Path(output)
+    out_path.write_text(full_html, encoding='utf-8')
+    print(f"Generado: {out_path.resolve()}")
+    try:
+        webbrowser.open(out_path.as_uri())
+    except Exception:
+        pass
+    return full_html
+
+def run_flow(code):
+    lines = [l.strip() for l in code.strip().split('\n') if l.strip() and not l.strip().startswith('//') and not l.strip().startswith('#')]
+    scope = {}
+    
+    for line in lines:
+        # 1. SCRAPE
+        m_scrape = re.match(
+            r'(\w+)\s*=\s*SCRAPE\s*\(\s*["\']([^"\']+)["\']\s*,\s*["\']([^"\']+)["\']\s*,\s*[\[\{](.+)[\]\}]\s*\)',
+            line
+        )
+        if m_scrape:
+            var_name = m_scrape.group(1)
+            url = m_scrape.group(2)
+            selector = m_scrape.group(3)
+            fields_str = m_scrape.group(4)
+            fields = {}
+            for fm in re.finditer(r'(\w+)\s*:\s*["\']([^"\']+)["\']\s*@\s*["\']([^"\']+)["\']', fields_str):
+                fields[fm.group(1)] = (fm.group(2), fm.group(3))
+            scope[var_name] = flow_scrape(url, selector, fields)
+            continue
+        
+        # 2. GRID > CARD
+        m_grid = re.match(
+            r'(\w+)\s*=\s*GRID\s+(\d+)\s*>\s*CARD\s*\(([^)]+)\)\s+(?:FROM|from)\s+(\w+)',
+            line
+        )
+        if m_grid:
+            view_var = m_grid.group(1)
+            cols = m_grid.group(2)
+            fields_list = [f.strip() for f in m_grid.group(3).split(',')]
+            from_var = m_grid.group(4)
+            data_source = scope.get(from_var, [])
+            scope[view_var] = flow_grid(data_source, cols, fields_list)
+            continue
+        
+        # 3. RENDER
+        m_render = re.match(r'RENDER\s+(\w+)', line)
+        if m_render:
+            render_var = m_render.group(1)
+            view_html = scope.get(render_var, "")
+            flow_render(view_html)
+            continue