grid-minion 0.1.0__tar.gz

grid_minion-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Iznardo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

grid_minion-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: grid-minion
+Version: 0.1.0
+Summary: Cliente no oficial de Python para las APIs de GRID (League of Legends)
+Author-email: Iznardo <contact@f1re.es>
+Project-URL: Homepage, https://github.com/tu_usuario/grid-minion
+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
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Provides-Extra: test
+Requires-Dist: python-dotenv>=1.0.0; extra == "test"
+Dynamic: license-file
+
+# Grid Minion
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+Grid Minion es un cliente de Python ligero y robusto para interactuar con las APIs de GRID.gg (Data Central y Live Data), diseñado específicamente para analistas y desarrolladores de League of Legends.
+
+Esta libreria no solo facilita la descarga de datos, sino que implementa un sistema de Observadores que procesa y cruza automaticamente los datos de GRID y Riot (PUUIDs, KDA, Objetivos, Vision) en tiempo real o diferido.
+
+## Caracteristicas
+
+*   Clientes Especializados:
+    *   GridGraphQLClient: Consulta de metadatos, torneos y series con paginacion automatica.
+    *   GridRestClient: Descarga de archivos (Summary, LiveStats, GRID Events) con gestion de descompresion ZIP.
+*   Sistema de Observadores: Procesa eventos complejos y mantiene el estado de la partida (Drafts, Inventarios, Posicionamiento).
+*   Robustez Industrial:
+    *   Gestion avanzada de Rate Limits (HTTP 429 y GraphQL body errors) con reintentos exponenciales.
+    *   Jerarquia de excepciones personalizadas (GridRateLimitError, GridAuthError, etc.).
+    *   Sistema de logging integrado.
+
+## Instalacion
+
+```bash
+pip install grid-minion
+```
+(O clonando el repo para desarrollo)
+```bash
+git clone https://github.com/tu_usuario/pyGrid.git
+cd pyGrid
+pip install -e .
+```
+
+## Inicio Rapido
+
+### 1. Consultar Series (GraphQL)
+```python
+from grid_minion import GridGraphQLClient
+
+client = GridGraphQLClient(api_key="TU_API_KEY")
+
+# Obtener IDs de series de la LEC en un rango de fechas
+series_ids = client.get_series(
+    start_time="2024-01-01T00:00:00Z",
+    tournament_ids=["ID_TORNEO"]
+)
+```
+
+### 2. Descargar y Procesar Partidas (Observers)
+El corazon de la libreria es el GameEventProcessor. Puedes enganchar diferentes observadores para obtener exactamente los datos que necesitas.
+
+```python
+from grid_minion import GridRestClient, split_grid_series
+from grid_minion.observers import (
+    GameEventProcessor, TeamsObserver, DraftObserver, 
+    PostGameObserver, ObjectiveKilledObserver, WardsObserver
+)
+
+client = GridRestClient(api_key="TU_API_KEY")
+processor = GameEventProcessor()
+
+# Instanciar observadores
+teams_obs = TeamsObserver()
+draft_obs = DraftObserver()
+wards_obs = WardsObserver(teams_observer=teams_obs) # Dependencia de equipos
+
+# Suscribirlos al procesador
+processor.attach(teams_obs)
+processor.attach(draft_obs)
+processor.attach(wards_obs)
+
+# Descargar datos
+grid_events = client.get_grid_events("SERIES_ID")
+riot_summary = client.get_riot_summary("SERIES_ID", game_number=1)
+
+# Procesar todo el paquete (el procesador gestiona el orden de ingesta)
+processor.process_bundle(
+    grid_livestats=grid_events,
+    riot_summary=riot_summary
+)
+
+# Acceder a los resultados limpios
+print(f"Draft: {draft_obs.get_draft()}")
+print(f"Wards totales: {len(wards_obs.get_wards())}")
+```
+
+## Manejo de Errores
+
+```python
+from grid_minion import GridRateLimitError, GridAuthError
+
+try:
+    data = client.query_central(query)
+except GridRateLimitError:
+    print("Se agotaron los reintentos de velocidad.")
+except GridAuthError:
+    print("API Key invalida.")
+```
+
+## Tests
+
+Ejecutar la suite de pruebas unitarias e integracion:
+```bash
+python -m unittest discover tests
+```
+
+## Licencia
+
+Este proyecto esta bajo la Licencia MIT. Consulta el archivo LICENSE para mas detalles.

grid_minion-0.1.0/README.md

@@ -0,0 +1,108 @@
+# Grid Minion
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+Grid Minion es un cliente de Python ligero y robusto para interactuar con las APIs de GRID.gg (Data Central y Live Data), diseñado específicamente para analistas y desarrolladores de League of Legends.
+
+Esta libreria no solo facilita la descarga de datos, sino que implementa un sistema de Observadores que procesa y cruza automaticamente los datos de GRID y Riot (PUUIDs, KDA, Objetivos, Vision) en tiempo real o diferido.
+
+## Caracteristicas
+
+*   Clientes Especializados:
+    *   GridGraphQLClient: Consulta de metadatos, torneos y series con paginacion automatica.
+    *   GridRestClient: Descarga de archivos (Summary, LiveStats, GRID Events) con gestion de descompresion ZIP.
+*   Sistema de Observadores: Procesa eventos complejos y mantiene el estado de la partida (Drafts, Inventarios, Posicionamiento).
+*   Robustez Industrial:
+    *   Gestion avanzada de Rate Limits (HTTP 429 y GraphQL body errors) con reintentos exponenciales.
+    *   Jerarquia de excepciones personalizadas (GridRateLimitError, GridAuthError, etc.).
+    *   Sistema de logging integrado.
+
+## Instalacion
+
+```bash
+pip install grid-minion
+```
+(O clonando el repo para desarrollo)
+```bash
+git clone https://github.com/tu_usuario/pyGrid.git
+cd pyGrid
+pip install -e .
+```
+
+## Inicio Rapido
+
+### 1. Consultar Series (GraphQL)
+```python
+from grid_minion import GridGraphQLClient
+
+client = GridGraphQLClient(api_key="TU_API_KEY")
+
+# Obtener IDs de series de la LEC en un rango de fechas
+series_ids = client.get_series(
+    start_time="2024-01-01T00:00:00Z",
+    tournament_ids=["ID_TORNEO"]
+)
+```
+
+### 2. Descargar y Procesar Partidas (Observers)
+El corazon de la libreria es el GameEventProcessor. Puedes enganchar diferentes observadores para obtener exactamente los datos que necesitas.
+
+```python
+from grid_minion import GridRestClient, split_grid_series
+from grid_minion.observers import (
+    GameEventProcessor, TeamsObserver, DraftObserver, 
+    PostGameObserver, ObjectiveKilledObserver, WardsObserver
+)
+
+client = GridRestClient(api_key="TU_API_KEY")
+processor = GameEventProcessor()
+
+# Instanciar observadores
+teams_obs = TeamsObserver()
+draft_obs = DraftObserver()
+wards_obs = WardsObserver(teams_observer=teams_obs) # Dependencia de equipos
+
+# Suscribirlos al procesador
+processor.attach(teams_obs)
+processor.attach(draft_obs)
+processor.attach(wards_obs)
+
+# Descargar datos
+grid_events = client.get_grid_events("SERIES_ID")
+riot_summary = client.get_riot_summary("SERIES_ID", game_number=1)
+
+# Procesar todo el paquete (el procesador gestiona el orden de ingesta)
+processor.process_bundle(
+    grid_livestats=grid_events,
+    riot_summary=riot_summary
+)
+
+# Acceder a los resultados limpios
+print(f"Draft: {draft_obs.get_draft()}")
+print(f"Wards totales: {len(wards_obs.get_wards())}")
+```
+
+## Manejo de Errores
+
+```python
+from grid_minion import GridRateLimitError, GridAuthError
+
+try:
+    data = client.query_central(query)
+except GridRateLimitError:
+    print("Se agotaron los reintentos de velocidad.")
+except GridAuthError:
+    print("API Key invalida.")
+```
+
+## Tests
+
+Ejecutar la suite de pruebas unitarias e integracion:
+```bash
+python -m unittest discover tests
+```
+
+## Licencia
+
+Este proyecto esta bajo la Licencia MIT. Consulta el archivo LICENSE para mas detalles.

grid_minion-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "grid-minion"
+version = "0.1.0"
+description = "Cliente no oficial de Python para las APIs de GRID (League of Legends)"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+  { name = "Iznardo", email = "contact@f1re.es" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "python-dotenv>=1.0.0",
+    "build",
+    "twine",
+]
+test = [
+    "python-dotenv>=1.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/tu_usuario/grid-minion"
+
+[tool.setuptools.packages.find]
+where = ["src"]

grid_minion-0.1.0/setup.cfg

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

grid_minion-0.1.0/src/grid_minion/__init__.py

@@ -0,0 +1,25 @@
+from .graphql_client import GridGraphQLClient
+from .rest_client import GridRestClient
+from .utils import split_grid_series
+from .exceptions import (
+    GridError,
+    GridAPIError,
+    GridAuthError,
+    GridRateLimitError,
+    GridResourceNotFoundError,
+    GridNetworkError,
+    GridDataError
+)
+
+__all__ = [
+    "GridGraphQLClient", 
+    "GridRestClient", 
+    "split_grid_series",
+    "GridError",
+    "GridAPIError",
+    "GridAuthError",
+    "GridRateLimitError",
+    "GridResourceNotFoundError",
+    "GridNetworkError",
+    "GridDataError"
+]

grid_minion-0.1.0/src/grid_minion/exceptions.py

@@ -0,0 +1,30 @@
+class GridError(Exception):
+    """Clase base para todas las excepciones de Grid Minion."""
+    pass
+
+class GridAPIError(GridError):
+    """Error devuelto por la API de GRID (status codes no exitosos o errores en el body)."""
+    def __init__(self, message, status_code=None, details=None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.details = details
+
+class GridAuthError(GridAPIError):
+    """Error de autenticación (API Key inválida o sin permisos)."""
+    pass
+
+class GridRateLimitError(GridAPIError):
+    """Límite de velocidad (Rate Limit) alcanzado y reintentos agotados."""
+    pass
+
+class GridResourceNotFoundError(GridAPIError):
+    """El recurso solicitado (ej: archivo de partida) no existe (404)."""
+    pass
+
+class GridNetworkError(GridError):
+    """Error de conexión, timeout o red al intentar comunicar con GRID."""
+    pass
+
+class GridDataError(GridError):
+    """Error al procesar, descomprimir o parsear los datos recibidos."""
+    pass

grid_minion-0.1.0/src/grid_minion/graphql_client.py

@@ -0,0 +1,282 @@
+import requests
+import json
+import time
+import logging
+from typing import List, Dict, Any, Optional, Union
+from .exceptions import GridAPIError, GridRateLimitError, GridNetworkError, GridError
+
+logger = logging.getLogger(__name__)
+
+class GridGraphQLClient:
+    """
+    Cliente para interactuar con las APIs de GraphQL de GRID.
+    
+    Proporciona métodos para consultar metadatos (Data Central) y el estado
+    en tiempo real de las series (Live Data).
+    """
+    URL_CENTRAL = 'https://api.grid.gg/central-data/graphql'
+    URL_LIVE = 'https://api.grid.gg/live-data-feed/series-state/graphql'
+
+    def __init__(self, api_key: str, max_retries: int = 7):
+        """
+        Inicializa el cliente GraphQL.
+
+        Args:
+            api_key (str): Tu clave de API de GRID.
+            max_retries (int): Número máximo de reintentos para Rate Limits (default: 7).
+        """
+        self.max_retries = max_retries
+        self.session = requests.Session()
+        self.session.headers.update({
+            "x-api-key": api_key,
+            "Content-Type": "application/json"
+        })
+
+    def _execute(self, url: str, query: str, variables: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Ejecuta una petición GraphQL con lógica de reintentos y manejo de errores.
+        """
+        payload = {"query": query}
+        if variables:
+            payload["variables"] = variables
+
+        # Bucle de reintentos
+        for attempt in range(1, self.max_retries + 1):
+            try:
+                # Factor de espera: 2s, 3s, 4.5s, 6.75s... (Más lento que antes)
+                default_wait = 10 * (1.5 ** (attempt - 1))
+
+                response = self.session.post(url, json=payload)
+                
+                # --- 1. GESTIÓN DE RATE LIMIT HTTP (429) ---
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    wait_time = float(retry_after) if retry_after else default_wait
+                    
+                    if attempt == self.max_retries:
+                         raise GridRateLimitError(f"Rate Limit HTTP 429 persistente tras {self.max_retries} intentos.", status_code=429)
+
+                    logger.warning(f"HTTP 429. Esperando {wait_time:.2f}s... ({attempt}/{self.max_retries})")
+                    time.sleep(wait_time)
+                    continue 
+
+                # Si es otro error HTTP (5xx, etc)
+                response.raise_for_status()
+                
+                # --- 2. GESTIÓN DE ERRORES EN EL BODY (GraphQL) ---
+                data = response.json()
+                
+                if "errors" in data:
+                    is_rate_limit = False
+                    error_msg = str(data['errors'])
+
+                    for error in data["errors"]:
+                        msg = error.get("message", "").lower()
+                        code = error.get("extensions", {}).get("errorDetail", "")
+                        
+                        if "rate limit" in msg or "ENHANCE_YOUR_CALM" in code:
+                            is_rate_limit = True
+                            break
+                    
+                    if is_rate_limit:
+                        # Si es el último intento, lanzamos error y no esperamos más
+                        if attempt == self.max_retries:
+                            raise GridRateLimitError(f"Rate Limit GraphQL persistente tras {self.max_retries} intentos. GRID dice: {error_msg}", details=data['errors'])
+
+                        logger.warning(f"Rate Limit GraphQL detectado. Esperando {default_wait:.2f}s... ({attempt}/{self.max_retries})")
+                        time.sleep(default_wait)
+                        continue # Reintentamos
+
+                    # Error legítimo de sintaxis o lógica (no se reintenta)
+                    raise GridAPIError(f"GraphQL Error: {data['errors']}", details=data['errors'])
+                
+                # ÉXITO
+                return data.get("data", {})
+
+            except requests.exceptions.RequestException as e:
+                if attempt == self.max_retries:
+                    raise GridNetworkError(f"Error de conexión Final tras {self.max_retries} intentos: {e}")
+                
+                logger.warning(f"Error de red ({e}). Reintentando en {default_wait:.2f}s...")
+                time.sleep(default_wait)
+                continue
+
+        # Este punto teóricamente es inalcanzable por los 'raise' en el último intento,
+        # pero por seguridad:
+        raise GridError("Error crítico: Fallo en la lógica de reintentos.")
+
+    def query_central(self, query_body: str, variables: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Ejecuta una consulta en GRID Data Central (Metadatos).
+
+        Args:
+            query_body (str): Cuerpo de la consulta GraphQL.
+            variables (Optional[Dict]): Variables para la consulta.
+
+        Returns:
+            Dict[str, Any]: Datos devueltos por la API.
+        """
+        return self._execute(self.URL_CENTRAL, query_body, variables)
+
+    def query_live(self, query_body: str, variables: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Ejecuta una consulta en GRID Live Data (Series State).
+
+        Args:
+            query_body (str): Cuerpo de la consulta GraphQL.
+            variables (Optional[Dict]): Variables para la consulta.
+
+        Returns:
+            Dict[str, Any]: Datos devueltos por la API.
+        """
+        return self._execute(self.URL_LIVE, query_body, variables)
+
+    def get_series(self, 
+                   start_time: Optional[str] = None, 
+                   end_time: Optional[str] = None, 
+                   game_type: Optional[str] = None,
+                   title_id: Union[int, List[int]] = 3, 
+                   page_games: int = 25,
+                   team_ids: Union[str, List[str]] = None, 
+                   tournament_ids: Union[str, List[str]] = None) -> List[str]:
+        """
+        Obtiene una lista de IDs de series filtradas por diversos criterios.
+        Maneja automáticamente la paginación de la API.
+
+        Args:
+            start_time (Optional[str]): Fecha de inicio (ISO 8601).
+            end_time (Optional[str]): Fecha de fin (ISO 8601).
+            game_type (Optional[str]): Tipo de partida (ej: 'COMPETITIVE').
+            title_id (Union[int, List[int]]): ID del juego (default: 3 para LoL).
+            page_games (int): Número de series por página (max: 25).
+            team_ids (Optional[Union[str, List[str]]]): IDs de equipos.
+            tournament_ids (Optional[Union[str, List[str]]]): IDs de torneos.
+
+        Returns:
+            List[str]: Lista de IDs de series encontrados.
+        """
+        
+        all_ids = []
+        filter_parts = ""
+
+        if start_time and end_time:
+            filter_parts += f'startTimeScheduled: {{ gte: "{start_time}", lte: "{end_time}" }}'
+        elif start_time:
+            filter_parts += f'startTimeScheduled: {{ gte: "{start_time}" }}'
+        elif end_time:
+            filter_parts += f'startTimeScheduled: {{ lte: "{end_time}" }}'
+
+        filter_parts += f'\n titleIds: {{ in: {json.dumps(title_id)} }}'
+
+        if game_type:
+            filter_parts += f'\n types: {game_type}'
+
+        if team_ids:
+            if isinstance(team_ids, list):
+                filter_parts += f'\n teamIds: {{ in: {json.dumps(team_ids)} }}'
+            else:
+                filter_parts += f'\n teamId: "{team_ids}"'
+
+        if tournament_ids:
+            if isinstance(tournament_ids, list):
+                filter_parts += f'\n tournamentIds: {{ in: {json.dumps(tournament_ids)} }}'
+            else:
+                filter_parts += f'\n tournamentId: "{tournament_ids}"'
+
+        def _fetch_page(cursor=""):
+            body = """
+            query GetGames {{
+                allSeries(
+                    after: "{cursor}"
+                    first: {page_games}
+                    filter: {{
+                        {filter_parts}
+                    }}
+                    orderBy: StartTimeScheduled
+                ) {{
+                    totalCount
+                    pageInfo {{
+                        hasNextPage
+                        endCursor
+                    }}
+                    edges {{
+                        node {{
+                            id
+                        }}
+                    }}
+                }}
+            }}
+            """.format(cursor=cursor, page_games=page_games, filter_parts=filter_parts)
+            
+            data = self.query_central(body)
+            series_data = data['allSeries']
+            
+            nodes = series_data['edges']
+            current_ids = [n['node']['id'] for n in nodes]
+            
+            return current_ids, series_data['pageInfo']['hasNextPage'], series_data['pageInfo']['endCursor']
+
+        has_next = True
+        cursor = ""
+        while has_next:
+            new_ids, has_next, cursor = _fetch_page(cursor)
+            all_ids.extend(new_ids)
+            
+        return all_ids
+
+    def get_tournament_ids_by_name(self, parent_names: List[str]) -> List[str]:
+        """
+        Busca IDs de torneos basándose en una lista de nombres o fragmentos de nombres.
+
+        Args:
+            parent_names (List[str]): Lista de nombres a buscar (ej: ['LEC', 'LVP']).
+
+        Returns:
+            List[str]: Lista de IDs de torneos que coinciden con la búsqueda.
+        """
+        found_ids = set()
+        for name in parent_names:
+            query = f"""
+            query {{
+              tournaments(first: 50, filter: {{ name: {{ contains: "{name}" }} }}) {{
+                edges {{
+                  node {{
+                    id
+                    name
+                  }}
+                }}
+              }}
+            }}
+            """
+            data = self.query_central(query)
+            edges = data.get("tournaments", {}).get("edges", [])
+            for edge in edges:
+                if name in edge["node"]["name"]:
+                    found_ids.add(edge["node"]["id"])
+        return list(found_ids)
+
+    def get_series_state(self, series_id: str) -> Dict[str, Any]:
+        """
+        Obtiene el estado actual de una serie (Live Data).
+
+        Args:
+            series_id (str): ID de la serie de GRID.
+
+        Returns:
+            Dict[str, Any]: Diccionario con el estado de la serie y sus partidas.
+        """
+        query = f"""
+        query {{
+            seriesState(id: {series_id}) {{
+                id
+                games {{
+                    id
+                    sequenceNumber
+                    started
+                    finished
+                }}
+            }}
+        }}
+        """
+        data = self.query_live(query)
+        return data["seriesState"]

grid_minion-0.1.0/src/grid_minion/observers/__init__.py

@@ -0,0 +1,18 @@
+from .base import Observer
+from .processor import GameEventProcessor
+from .teams import TeamsObserver, Participant
+from .drafts import DraftObserver
+from .stats import PostGameObserver
+from .objectives import ObjectiveKilledObserver
+from .vision import WardsObserver
+
+__all__ = [
+    "Observer",
+    "GameEventProcessor",
+    "TeamsObserver",
+    "Participant",
+    "DraftObserver",
+    "PostGameObserver",
+    "ObjectiveKilledObserver",
+    "WardsObserver"
+]

grid_minion-0.1.0/src/grid_minion/observers/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+class Observer(ABC):
+    """
+    Clase base abstracta para todos los observadores de eventos.
+
+    Cualquier clase que desee procesar eventos del GameEventProcessor debe
+    heredar de esta clase e implementar el método notify_event.
+    """
+    @abstractmethod
+    def notify_event(self, event: Dict[str, Any]):
+        """
+        Recibe un evento y decide si procesarlo.
+
+        Args:
+            event (Dict[str, Any]): Diccionario que contiene los datos del evento,
+                incluyendo 'source', 'type' o 'rfc461Schema' dependiendo de la fuente.
+        """
+        pass