antigravity-lite 0.1.0__tar.gz

antigravity_lite-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: antigravity-lite
+Version: 0.1.0
+Summary: Herramienta open-source para auditar despilfarros financieros en clústeres PySpark (AWS Glue) y manipular S3.
+Author-email: Arquitecto B2B <arquitecto@antigravity.dev>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: boto3>=1.26.0
+
+# 🛸 Antigravity PySpark Framework
+
+Enterprise framework para resolver problemas complejos de Big Data en AWS Glue y entornos PySpark puros sin esfuerzo. Este proyecto estandariza las mejores prácticas de la industria con un solo `import`.
+
+## 📦 Empaquetado y Licenciamiento Comercial (SaaS B2B)
+
+Si deseas vender y distribuir este framework a una empresa externa, es imperativo **proteger tu Propiedad Intelectual** (ofuscar el código fuente) y **venderlo con una licencia temporal** (para que te paguen la renovación).
+
+### 1. Ofuscar el código y armar la "Bomba de Tiempo" (Expiración)
+Antes de construir el paquete, encripta el código fuente y configúrale la fecha de vencimiento exacta del contrato del cliente (ej. 31 de Diciembre de 2027):
+
+```bash
+# 1. Asegúrate de estar en el entorno virtual
+source .venv/bin/activate
+
+# 2. Generar el binario comercial ofuscado (.whl) con Bomba de Tiempo (2027)
+python build_commercial.py
+```
+Este script (que te escribí a la medida) automatizará por ti la encriptación con PyArmor y el empaquetado directo hacia la carpeta `dist/`. Cualquier ingeniero externo que intente abrir tus archivos allí dentro verá código basura indescifrable.
+
+### 2. Construcción de uso interno / Open-Source (`.whl`)
+Para el empaquetado inicial (sin ofuscación) para probar el framework dentro de tu propio AWS Glue, ejecuta el empaquetado estándar de Python:
+```bash
+# Construye el antigravity-0.1.0-py3-none-any.whl en la carpeta dist/
+pip install build
+python -m build
+```
+
+---
+
+## 🚀 Guía de Uso Rápido para Ingenieros
+
+### Motor A: Optimizador Core (`DataFrameChunker`)
+**¿Cuándo usarlo?** Cuando lidias con DataFrames anchos (Wide DataFrames) o realizas analítica que provoca errores de `OutOfMemory` (OOM), demoras extremas, o fallos de `StackOverflowError`. Funciona fluidamente con cualquier volumen de datos y columnas, auto-regulando la memoria del clúster para acelerar los cruces matemáticos pesados.
+
+**¿Cómo funciona?**
+Particiona el DataFrame verticalmente e inyecta `localCheckpoint()` para aislar la memoria del Catalyst Optimizer.
+
+```python
+from antigravity.core import DataFrameChunker
+
+# 1. Instancias el chunker indicando la llave primaria y cuántas columnas procesar a la vez.
+chunker = DataFrameChunker(df_masivo, id_cols=["id_cliente"], chunk_size=50)
+
+# 2. Defines tú lógica matemática. Spark solo le pasará 50 variables por iteración.
+def mi_logica(chunk_df, indice):
+    # Calcula algo y retorna un DF más pequeño
+    return chunk_df.select("id_cliente", ...)
+
+# 3. El framework ejecuta el bucle de forma segura en el clúster
+resultados_parciales = chunker.process_chunks(mi_logica)
+```
+
+### Motor B: Generador Legacy (`LegacyTextTransformer`)
+**¿Cuándo usarlo?** Cuando el negocio, banco, o gobierno te exige generar archivos `.TXT` planos, asimétricos o posicionales a partir de datos tabulares modernos.
+
+**¿Cómo funciona?**
+Recibe el DataFrame y usa `RDD.flatMap` para aplicar lógica de python puro distribuidamente.
+
+```python
+from antigravity.legacy import LegacyTextTransformer
+
+# 1. Escribes las reglas del negocio (1 Fila de Spark = N líneas de texto)
+def reglas_bancarias(fila):
+    yield f"HEADER_{fila.id}"
+    yield f"BODY_{fila.saldo}"
+
+# 2. Invocas el framework
+transformer = LegacyTextTransformer(df)
+
+# 3. Generas la salida
+transformer.save_as_text(reglas_bancarias, "s3://mi-bucket/banco_txt/")
+```
+
+### Motor IO: Smart Exporter (`S3Finalizer`)
+**¿Cuándo usarlo?** Cuando detestas que PySpark guarde tus archivos como `part-0000X.csv` y deje basura como los archivos `_SUCCESS` en tu S3.
+
+**¿Cómo funciona?**
+Se conecta mediante `boto3` para listar, ordenar, secuenciar y renombrar la salida de Spark.
+
+```python
+from antigravity.io import S3Finalizer
+
+# 1. Escribes tu DataFrame normal en Spark
+df.write.parquet("s3://mi-bucket/salida_sucia/")
+
+# 2. Invocas el framework para secuenciarlos inteligentemente e inyectar el formato
+finalizador = S3Finalizer(bucket_name="mi-bucket")
+finalizador.sequence_spark_outputs(
+    s3_prefix="salida_sucia/",
+    pattern="MI_EMPRESA_DATA_{seq:04d}.parquet" # Resultado: MI_EMPRESA_DATA_0001.parquet
+)
+```

antigravity_lite-0.1.0/README.md

@@ -0,0 +1,93 @@
+# 🛸 Antigravity PySpark Framework
+
+Enterprise framework para resolver problemas complejos de Big Data en AWS Glue y entornos PySpark puros sin esfuerzo. Este proyecto estandariza las mejores prácticas de la industria con un solo `import`.
+
+## 📦 Empaquetado y Licenciamiento Comercial (SaaS B2B)
+
+Si deseas vender y distribuir este framework a una empresa externa, es imperativo **proteger tu Propiedad Intelectual** (ofuscar el código fuente) y **venderlo con una licencia temporal** (para que te paguen la renovación).
+
+### 1. Ofuscar el código y armar la "Bomba de Tiempo" (Expiración)
+Antes de construir el paquete, encripta el código fuente y configúrale la fecha de vencimiento exacta del contrato del cliente (ej. 31 de Diciembre de 2027):
+
+```bash
+# 1. Asegúrate de estar en el entorno virtual
+source .venv/bin/activate
+
+# 2. Generar el binario comercial ofuscado (.whl) con Bomba de Tiempo (2027)
+python build_commercial.py
+```
+Este script (que te escribí a la medida) automatizará por ti la encriptación con PyArmor y el empaquetado directo hacia la carpeta `dist/`. Cualquier ingeniero externo que intente abrir tus archivos allí dentro verá código basura indescifrable.
+
+### 2. Construcción de uso interno / Open-Source (`.whl`)
+Para el empaquetado inicial (sin ofuscación) para probar el framework dentro de tu propio AWS Glue, ejecuta el empaquetado estándar de Python:
+```bash
+# Construye el antigravity-0.1.0-py3-none-any.whl en la carpeta dist/
+pip install build
+python -m build
+```
+
+---
+
+## 🚀 Guía de Uso Rápido para Ingenieros
+
+### Motor A: Optimizador Core (`DataFrameChunker`)
+**¿Cuándo usarlo?** Cuando lidias con DataFrames anchos (Wide DataFrames) o realizas analítica que provoca errores de `OutOfMemory` (OOM), demoras extremas, o fallos de `StackOverflowError`. Funciona fluidamente con cualquier volumen de datos y columnas, auto-regulando la memoria del clúster para acelerar los cruces matemáticos pesados.
+
+**¿Cómo funciona?**
+Particiona el DataFrame verticalmente e inyecta `localCheckpoint()` para aislar la memoria del Catalyst Optimizer.
+
+```python
+from antigravity.core import DataFrameChunker
+
+# 1. Instancias el chunker indicando la llave primaria y cuántas columnas procesar a la vez.
+chunker = DataFrameChunker(df_masivo, id_cols=["id_cliente"], chunk_size=50)
+
+# 2. Defines tú lógica matemática. Spark solo le pasará 50 variables por iteración.
+def mi_logica(chunk_df, indice):
+    # Calcula algo y retorna un DF más pequeño
+    return chunk_df.select("id_cliente", ...)
+
+# 3. El framework ejecuta el bucle de forma segura en el clúster
+resultados_parciales = chunker.process_chunks(mi_logica)
+```
+
+### Motor B: Generador Legacy (`LegacyTextTransformer`)
+**¿Cuándo usarlo?** Cuando el negocio, banco, o gobierno te exige generar archivos `.TXT` planos, asimétricos o posicionales a partir de datos tabulares modernos.
+
+**¿Cómo funciona?**
+Recibe el DataFrame y usa `RDD.flatMap` para aplicar lógica de python puro distribuidamente.
+
+```python
+from antigravity.legacy import LegacyTextTransformer
+
+# 1. Escribes las reglas del negocio (1 Fila de Spark = N líneas de texto)
+def reglas_bancarias(fila):
+    yield f"HEADER_{fila.id}"
+    yield f"BODY_{fila.saldo}"
+
+# 2. Invocas el framework
+transformer = LegacyTextTransformer(df)
+
+# 3. Generas la salida
+transformer.save_as_text(reglas_bancarias, "s3://mi-bucket/banco_txt/")
+```
+
+### Motor IO: Smart Exporter (`S3Finalizer`)
+**¿Cuándo usarlo?** Cuando detestas que PySpark guarde tus archivos como `part-0000X.csv` y deje basura como los archivos `_SUCCESS` en tu S3.
+
+**¿Cómo funciona?**
+Se conecta mediante `boto3` para listar, ordenar, secuenciar y renombrar la salida de Spark.
+
+```python
+from antigravity.io import S3Finalizer
+
+# 1. Escribes tu DataFrame normal en Spark
+df.write.parquet("s3://mi-bucket/salida_sucia/")
+
+# 2. Invocas el framework para secuenciarlos inteligentemente e inyectar el formato
+finalizador = S3Finalizer(bucket_name="mi-bucket")
+finalizador.sequence_spark_outputs(
+    s3_prefix="salida_sucia/",
+    pattern="MI_EMPRESA_DATA_{seq:04d}.parquet" # Resultado: MI_EMPRESA_DATA_0001.parquet
+)
+```

antigravity_lite-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "antigravity-lite"
+version = "0.1.0"
+description = "Herramienta open-source para auditar despilfarros financieros en clústeres PySpark (AWS Glue) y manipular S3."
+readme = "README.md"
+authors = [
+    { name = "Arquitecto B2B", email = "arquitecto@antigravity.dev" }
+]
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "boto3>=1.26.0"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src_lite"}
+packages = ["antigravity_lite", "antigravity_lite.io", "antigravity_lite.auditor"]

antigravity_lite-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

antigravity_lite-0.1.0/src_lite/antigravity_lite/auditor/finops.py

@@ -0,0 +1,142 @@
+import boto3
+import logging
+from datetime import datetime, timedelta, timezone
+
+logger = logging.getLogger(__name__)
+
+class AgAuditor:
+    """
+    Antigravity Lite - Glue Cost & FinOps Auditor
+    ========================================
+    Herramienta de auditoría financiera y operativa para AWS Glue.
+    Evalúa si estás pagando sobrecostos masivos en la nube debido a bucles infinitos 
+    o configuraciones de RAM infladas para encubrir fallos del Catalyst Optimizer.
+    """
+    
+    @staticmethod
+    def get_dpu_price(region: str) -> float:
+        # Standard AWS Glue DPU per hour cost
+        return 0.44 
+
+    @classmethod
+    def run_aws_audit(cls, region="us-east-1", dias_analisis=7):
+        print(f"\n🔍 [ANTIGRAVITY LITE] Iniciando Auditoría FinOps (Región: {region})...")
+        print(f"Analizando métricas de los últimos {dias_analisis} días...\n")
+        
+        try:
+            glue_client = boto3.client('glue', region_name=region)
+            cw_client = boto3.client('cloudwatch', region_name=region)
+            glue_client.get_jobs(MaxResults=1)
+        except Exception as e:
+            print("❌ Error de Autenticación AWS. Verifique sus credenciales Boto3.")
+            return
+
+        tiempo_limite = datetime.now(timezone.utc) - timedelta(days=dias_analisis)
+        
+        jobs = []
+        paginator = glue_client.get_paginator('get_jobs')
+        for page in paginator.paginate():
+            for job in page.get('Jobs', []):
+                jobs.append(job['Name'])
+                
+        if not jobs:
+            print("No se encontraron Jobs de AWS Glue desplegados.")
+            return
+            
+        print(f"📡 Se descubrieron {len(jobs)} Jobs. Calculando desperdicio (DPUs)...\n")
+        
+        costo_dpu_hora = cls.get_dpu_price(region)
+        resultados = []
+        
+        print(f"{'NOMBRE DEL JOB':<35} | {'WORKER TYPE':<12} | {'DPUs':<6} | {'MAX RAM %':<12} | {'GASTO EST. (7d)'}")
+        print("-" * 90)
+
+        for job_name in jobs:
+            runs_validos = 0
+            total_horas_ejecucion = 0
+            dpus_reales_promedio = 0
+            ultimo_worker_type = "N/A"
+            
+            runs_paginator = glue_client.get_paginator('get_job_runs')
+            try:
+                for page in runs_paginator.paginate(JobName=job_name):
+                    for run in page.get('JobRuns', []):
+                        if run.get('StartedOn', datetime.min.replace(tzinfo=timezone.utc)) < tiempo_limite:
+                            continue
+                        
+                        runs_validos += 1
+                        
+                        if 'CompletedOn' in run and 'StartedOn' in run:
+                            duracion_segundos = (run['CompletedOn'] - run['StartedOn']).total_seconds()
+                            total_horas_ejecucion += (duracion_segundos / 3600.0)
+                            
+                        worker_type = run.get('WorkerType', 'G.1X')
+                        num_workers = run.get('NumberOfWorkers', run.get('MaxCapacity', 2))
+                        
+                        peso_dpu = {'Standard': 1, 'G.1X': 1, 'G.2X': 2, 'G.4X': 4, 'G.8X': 8, 'Z.2X': 2}
+                        dpus_reales = num_workers * peso_dpu.get(worker_type, 1)
+                        
+                        dpus_reales_promedio = dpus_reales
+                        ultimo_worker_type = worker_type
+                        
+            except Exception:
+                continue 
+                
+            if runs_validos == 0:
+                continue
+                
+            max_memory_percent = 0.0
+            try:
+                metric_response = cw_client.get_metric_statistics(
+                    Namespace='Glue',
+                    MetricName='glue.driver.jvm.heap.usage', 
+                    Dimensions=[
+                        {'Name': 'JobName', 'Value': job_name},
+                        {'Name': 'Type', 'Value': 'gauge'}
+                    ],
+                    StartTime=tiempo_limite,
+                    EndTime=datetime.now(timezone.utc),
+                    Period=3600,
+                    Statistics=['Maximum']
+                )
+                datapoints = metric_response.get('Datapoints', [])
+                if datapoints:
+                    max_memory_percent = max([dp['Maximum'] for dp in datapoints]) * 100
+            except Exception:
+                pass 
+                
+            gasto_total = total_horas_ejecucion * dpus_reales_promedio * costo_dpu_hora
+            
+            if gasto_total > 0:
+                resultados.append({
+                    "nombre": job_name,
+                    "runs": runs_validos,
+                    "dpus": dpus_reales_promedio,
+                    "worker_type": ultimo_worker_type,
+                    "memoria": max_memory_percent,
+                    "gasto": gasto_total
+                })
+                
+        resultados = sorted(resultados, key=lambda x: x["gasto"], reverse=True)
+        
+        total_desperdicio = 0
+        for res in resultados[:10]:
+            mem_str = f"{res['memoria']:.1f}%" if res['memoria'] > 0 else "N/A"
+            
+            if res['memoria'] > 85.0 or res['worker_type'] in ['G.4X', 'G.8X']:
+                total_desperdicio += (res['gasto'] * 0.6)
+                mem_str += " ⚠️ RIESGO AST"
+                
+            print(f"{res['nombre']:<35} | {res['worker_type']:<12} | {res['dpus']:<6.1f} | {mem_str:<12} | ${res['gasto']:,.2f}")
+            
+        print("-" * 90)
+        print(f"\n🚨 REPORTE DE FUGA DE CAPITAL AWS:")
+        print(f"Estás perdiendo un estimado de: ${total_desperdicio * 4:,.2f} USD al mes pagando instancias gigantes.")
+        
+        print("\n=========================================================================================")
+        print("💡 [TROJAN HOOK] ¿Tu script se ahoga con Wide Dataframes y tienes que pagar más RAM?")
+        print("El Catalyst Optimizer de Spark es el culpable. No pagues más en AWS Glue.")
+        print("Descarga la licencia B2B de 'Antigravity Pro' para obtener el 'DataFrameChunker' matemático.")
+        print("Corta tu factura de G.4X a G.1X hoy mismo contactando al Arquitecto de Datos.")
+        print("Más información: linkedin.com/in/tu-perfil-aqui")
+        print("=========================================================================================\n")

antigravity_lite-0.1.0/src_lite/antigravity_lite/io/s3_finalizer.py

@@ -0,0 +1,165 @@
+"""
+Motor IO: Smart S3 Exporter (S3Finalizer)
+=========================================
+Maneja la "Última Milla" del procesamiento de PySpark en AWS.
+Convierte las salidas nativas de Spark (ej. part-0000...) en archivos limpios, legibles y secuenciados.
+"""
+import time
+import logging
+import concurrent.futures
+from typing import List, Optional
+
+try:
+    import boto3
+    from botocore.exceptions import ClientError
+except ImportError:
+    boto3 = None
+
+logger = logging.getLogger(__name__)
+
+class S3Finalizer:
+    """
+    Abstracción inteligente para manejar las operaciones en S3.
+    Evita el molesto comportamiento por defecto de Spark limpiando archivos 
+    intermedios y renombrando la salida.
+    """
+    
+    def __init__(self, bucket_name: str, aws_region: str = 'us-east-1', mock_s3_client=None):
+        self.bucket = bucket_name
+        self.region = aws_region
+        
+        if mock_s3_client:
+            self.s3 = mock_s3_client
+        elif boto3:
+            self.s3 = boto3.client('s3', region_name=self.region)
+        else:
+            raise ImportError("La librería 'boto3' no está instalada.")
+            
+    def list_keys(self, prefix: str) -> List[str]:
+        keys = []
+        paginator = self.s3.get_paginator('list_objects_v2')
+        pages = paginator.paginate(Bucket=self.bucket, Prefix=prefix)
+        for page in pages:
+            for obj in page.get('Contents', []):
+                keys.append(obj['Key'])
+        return keys
+
+    def rename_spark_output(self, s3_prefix: str, final_filename: str, max_retries: int = 3) -> bool:
+        """
+        Archivos únicos: Cambia part-0000.ext a final_filename.
+        (Ideal para salidas coalescidas df.coalesce(1))
+        """
+        if not s3_prefix.endswith('/'): s3_prefix += '/'
+
+        all_keys = []
+        for attempt in range(max_retries):
+            all_keys = self.list_keys(s3_prefix)
+            if any(k.split("/")[-1].startswith("part-") for k in all_keys):
+                break
+            time.sleep(2)
+            
+        part_key = None
+        keys_to_delete = []
+        
+        for key in all_keys:
+            basename = key.split("/")[-1]
+            if basename.startswith("part-"):
+                part_key = key
+            elif basename != final_filename:
+                keys_to_delete.append({'Key': key})
+                
+        if not part_key:
+            logger.warning(f"No se encontró salida 'part-' en {self.bucket}/{s3_prefix}")
+            return False
+            
+        new_key = f"{s3_prefix}{final_filename}"
+        try:
+            self.s3.copy_object(Bucket=self.bucket, CopySource={'Bucket': self.bucket, 'Key': part_key}, Key=new_key)
+            keys_to_delete.append({'Key': part_key})
+            logger.info(f"Éxito: Salida renombrada a s3://{self.bucket}/{new_key}")
+            self._batch_delete(keys_to_delete)
+            return True
+        except Exception as e:
+            logger.error(f"Fallo al renombrar {s3_prefix}: {str(e)}")
+            return False
+
+    def sequence_spark_outputs(self, s3_prefix: str, pattern: str, extension: Optional[str] = None, max_retries: int = 3, max_workers: int = 20) -> int:
+        """
+        Archivos Múltiples: Encuentra TODOS los part-*.ext generados por Spark, 
+        los ordena, y los renombra secuencialmente usando "hilos" en paralelo de Boto3.
+        
+        :param s3_prefix: La ruta de salida.
+        :param pattern: El patrón del nombre deseado, ej: 'SBX.202701.{seq:04d}.SAL.gz'
+        :param extension: Opcional. Si se provee, ignora partes que no tengan esta extensión.
+        :param max_workers: Cantidad de hilos de red concurrentes de AWS.
+        :return: Número de archivos renombrados correctamente.
+        """
+        if not s3_prefix.endswith('/'): s3_prefix += '/'
+
+        all_keys = []
+        for attempt in range(max_retries):
+            all_keys = self.list_keys(s3_prefix)
+            if any(k.split("/")[-1].startswith("part-") for k in all_keys):
+                break
+            time.sleep(2)
+
+        part_keys = []
+        keys_to_delete = []
+
+        # Filtrar
+        for key in all_keys:
+            basename = key.split("/")[-1]
+            if basename.startswith("part-"):
+                if extension and not basename.endswith(extension):
+                    keys_to_delete.append({'Key': key})
+                else:
+                    part_keys.append(key)
+            elif "_SUCCESS" in basename:
+                keys_to_delete.append({'Key': key})
+
+        if not part_keys:
+            logger.warning(f"No hay partes coincidentes ('{extension}') en {s3_prefix}")
+            return 0
+
+        # Ordenar (part-00000, part-00001...) nos asegura secuenciación determinista
+        part_keys.sort()
+        
+        rename_tasks = []
+        for i, old_part_key in enumerate(part_keys, start=1):
+            # Soporta formato {seq:04d} -> 0001, 0002...
+            try:
+                new_basename = pattern.format(seq=i)
+            except KeyError:
+                new_basename = pattern.replace("{seq}", str(i)) # Seguridad por si el usuario pasa un string roto
+                
+            new_key = f"{s3_prefix}{new_basename}"
+            rename_tasks.append((old_part_key, new_key))
+            keys_to_delete.append({'Key': old_part_key})
+
+        successful_renames = 0
+
+        def _copy(task):
+            src, dst = task
+            try:
+                self.s3.copy_object(Bucket=self.bucket, CopySource={'Bucket': self.bucket, 'Key': src}, Key=dst)
+                return True
+            except Exception as e:
+                logger.error(f"Fallo copiando {src} a {dst}: {e}")
+                return False
+
+        # Procesamiento Paralelo en AWS
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            results = executor.map(_copy, rename_tasks)
+            successful_renames = sum(1 for r in results if r)
+
+        logger.info(f"Éxito: {successful_renames}/{len(part_keys)} archivos secuenciados.")
+        self._batch_delete(keys_to_delete)
+        return successful_renames
+        
+    def _batch_delete(self, keys: List[dict]):
+        if not keys: return
+        for i in range(0, len(keys), 1000):
+            try: # maximoAWS permite 1000 borrados por batch
+                self.s3.delete_objects(Bucket=self.bucket, Delete={'Objects': keys[i:i+1000], 'Quiet': True})
+            except Exception as e:
+                logger.error(f"Fallo limpiando basura S3: {e}")

antigravity_lite-0.1.0/src_lite/antigravity_lite.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: antigravity-lite
+Version: 0.1.0
+Summary: Herramienta open-source para auditar despilfarros financieros en clústeres PySpark (AWS Glue) y manipular S3.
+Author-email: Arquitecto B2B <arquitecto@antigravity.dev>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: boto3>=1.26.0
+
+# 🛸 Antigravity PySpark Framework
+
+Enterprise framework para resolver problemas complejos de Big Data en AWS Glue y entornos PySpark puros sin esfuerzo. Este proyecto estandariza las mejores prácticas de la industria con un solo `import`.
+
+## 📦 Empaquetado y Licenciamiento Comercial (SaaS B2B)
+
+Si deseas vender y distribuir este framework a una empresa externa, es imperativo **proteger tu Propiedad Intelectual** (ofuscar el código fuente) y **venderlo con una licencia temporal** (para que te paguen la renovación).
+
+### 1. Ofuscar el código y armar la "Bomba de Tiempo" (Expiración)
+Antes de construir el paquete, encripta el código fuente y configúrale la fecha de vencimiento exacta del contrato del cliente (ej. 31 de Diciembre de 2027):
+
+```bash
+# 1. Asegúrate de estar en el entorno virtual
+source .venv/bin/activate
+
+# 2. Generar el binario comercial ofuscado (.whl) con Bomba de Tiempo (2027)
+python build_commercial.py
+```
+Este script (que te escribí a la medida) automatizará por ti la encriptación con PyArmor y el empaquetado directo hacia la carpeta `dist/`. Cualquier ingeniero externo que intente abrir tus archivos allí dentro verá código basura indescifrable.
+
+### 2. Construcción de uso interno / Open-Source (`.whl`)
+Para el empaquetado inicial (sin ofuscación) para probar el framework dentro de tu propio AWS Glue, ejecuta el empaquetado estándar de Python:
+```bash
+# Construye el antigravity-0.1.0-py3-none-any.whl en la carpeta dist/
+pip install build
+python -m build
+```
+
+---
+
+## 🚀 Guía de Uso Rápido para Ingenieros
+
+### Motor A: Optimizador Core (`DataFrameChunker`)
+**¿Cuándo usarlo?** Cuando lidias con DataFrames anchos (Wide DataFrames) o realizas analítica que provoca errores de `OutOfMemory` (OOM), demoras extremas, o fallos de `StackOverflowError`. Funciona fluidamente con cualquier volumen de datos y columnas, auto-regulando la memoria del clúster para acelerar los cruces matemáticos pesados.
+
+**¿Cómo funciona?**
+Particiona el DataFrame verticalmente e inyecta `localCheckpoint()` para aislar la memoria del Catalyst Optimizer.
+
+```python
+from antigravity.core import DataFrameChunker
+
+# 1. Instancias el chunker indicando la llave primaria y cuántas columnas procesar a la vez.
+chunker = DataFrameChunker(df_masivo, id_cols=["id_cliente"], chunk_size=50)
+
+# 2. Defines tú lógica matemática. Spark solo le pasará 50 variables por iteración.
+def mi_logica(chunk_df, indice):
+    # Calcula algo y retorna un DF más pequeño
+    return chunk_df.select("id_cliente", ...)
+
+# 3. El framework ejecuta el bucle de forma segura en el clúster
+resultados_parciales = chunker.process_chunks(mi_logica)
+```
+
+### Motor B: Generador Legacy (`LegacyTextTransformer`)
+**¿Cuándo usarlo?** Cuando el negocio, banco, o gobierno te exige generar archivos `.TXT` planos, asimétricos o posicionales a partir de datos tabulares modernos.
+
+**¿Cómo funciona?**
+Recibe el DataFrame y usa `RDD.flatMap` para aplicar lógica de python puro distribuidamente.
+
+```python
+from antigravity.legacy import LegacyTextTransformer
+
+# 1. Escribes las reglas del negocio (1 Fila de Spark = N líneas de texto)
+def reglas_bancarias(fila):
+    yield f"HEADER_{fila.id}"
+    yield f"BODY_{fila.saldo}"
+
+# 2. Invocas el framework
+transformer = LegacyTextTransformer(df)
+
+# 3. Generas la salida
+transformer.save_as_text(reglas_bancarias, "s3://mi-bucket/banco_txt/")
+```
+
+### Motor IO: Smart Exporter (`S3Finalizer`)
+**¿Cuándo usarlo?** Cuando detestas que PySpark guarde tus archivos como `part-0000X.csv` y deje basura como los archivos `_SUCCESS` en tu S3.
+
+**¿Cómo funciona?**
+Se conecta mediante `boto3` para listar, ordenar, secuenciar y renombrar la salida de Spark.
+
+```python
+from antigravity.io import S3Finalizer
+
+# 1. Escribes tu DataFrame normal en Spark
+df.write.parquet("s3://mi-bucket/salida_sucia/")
+
+# 2. Invocas el framework para secuenciarlos inteligentemente e inyectar el formato
+finalizador = S3Finalizer(bucket_name="mi-bucket")
+finalizador.sequence_spark_outputs(
+    s3_prefix="salida_sucia/",
+    pattern="MI_EMPRESA_DATA_{seq:04d}.parquet" # Resultado: MI_EMPRESA_DATA_0001.parquet
+)
+```

antigravity_lite-0.1.0/src_lite/antigravity_lite.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src_lite/antigravity_lite/__init__.py
+src_lite/antigravity_lite.egg-info/PKG-INFO
+src_lite/antigravity_lite.egg-info/SOURCES.txt
+src_lite/antigravity_lite.egg-info/dependency_links.txt
+src_lite/antigravity_lite.egg-info/requires.txt
+src_lite/antigravity_lite.egg-info/top_level.txt
+src_lite/antigravity_lite/auditor/__init__.py
+src_lite/antigravity_lite/auditor/finops.py
+src_lite/antigravity_lite/io/__init__.py
+src_lite/antigravity_lite/io/s3_finalizer.py

antigravity_lite-0.1.0/src_lite/antigravity_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

antigravity_lite-0.1.0/src_lite/antigravity_lite.egg-info/requires.txt

@@ -0,0 +1 @@
+boto3>=1.26.0

antigravity_lite-0.1.0/src_lite/antigravity_lite.egg-info/top_level.txt

@@ -0,0 +1 @@
+antigravity_lite