flowtask 5.8.4__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/components/ProductInfo/parsers/brother.py

@@ -0,0 +1,97 @@
+import re
+from typing import Dict, Any, Optional, List
+from bs4 import BeautifulSoup
+from .base import ParserBase
+
+class BrotherParser(ParserBase):
+    """
+    Parser for Brother product information.
+    
+    Extracts product details from Brother's USA website using Selenium.
+    """
+    domain = "brother-usa.com"
+    search_format = "site:brother-usa.com {}"
+    product_url_pattern = "brother-usa.com/products/"
+    
+    async def parse(self, url: str, search_term: str, retailer: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Parse product information from a Brother URL using Selenium.
+        
+        Args:
+            url: Brother product URL
+            search_term: Original search term
+            retailer: Optional retailer information (not used for Brother)
+            
+        Returns:
+            Dictionary with product information
+        """
+        result = {
+            "source_url": url,
+            "search_term": search_term,
+            "model_code": None,
+            "product_name": None,
+            "price": None,
+            "specs": None,
+            "images": None,
+            "parse_status": "pending"
+        }
+        
+        try:
+            self.headless = True
+            driver = await self.get_driver()
+            await self.get_page(url)
+            
+            page_content = driver.page_source
+            soup = BeautifulSoup(page_content, "html.parser")
+            
+            # Extract model code - usando el selector exacto de la captura
+            model_elem = soup.select_one("h1.janus-model-number")
+            if model_elem:
+                result["model_code"] = model_elem.text.strip()
+            
+            # Extract product name - usando el selector exacto de la captura
+            name_elem = soup.select_one("h2.janus-product-title")
+            if name_elem:
+                result["product_name"] = name_elem.text.strip()
+            
+            # Extract price (ajustar según el sitio real)
+            price_elem = soup.select_one("span.price")  # Ajustar según el sitio real
+            if price_elem:
+                result["price"] = price_elem.text.strip()
+            
+            # Extract image (ajustar según el sitio real)
+            main_img = soup.select_one("img.product-image")  # Ajustar según el sitio real
+            if main_img:
+                src = main_img.get("src")
+                if src:
+                    if not src.startswith(("http://", "https://")):
+                        src = f"https://{self.domain}{src}" if src.startswith("/") else f"https://{self.domain}/{src}"
+                    result["images"] = [src]
+            
+            result["parse_status"] = "success"
+            
+        except Exception as e:
+            self._logger.error(f"Error parsing Brother product: {str(e)}")
+            result["parse_status"] = f"error: {str(e)}"
+        finally:
+            self.close_driver()
+            
+        return result
+
+    def get_product_urls(self, search_results: List[Dict[str, str]], max_urls: int = 5) -> List[str]:
+        """
+        Extract relevant product URLs from search results.
+        
+        Args:
+            search_results: List of search result dictionaries
+            max_urls: Maximum number of URLs to return
+            
+        Returns:
+            List of product URLs that match the Brother product pattern
+        """
+        urls = []
+        for result in search_results[:max_urls]:
+            url = result.get('link') or result.get('href') or result.get('url')
+            if url and self.domain in url and self.product_url_pattern in url:
+                urls.append(url)
+        return urls 

flowtask/components/ProductInfo/parsers/canon.py

@@ -0,0 +1,167 @@
+import re
+from typing import Dict, Any, Optional, List
+from bs4 import BeautifulSoup
+from .base import ParserBase
+
+class CanonParser(ParserBase):
+    """
+    Parser for Canon product information.
+    
+    Extracts product details from Canon's USA and Canada websites using Selenium.
+    """
+    domain_us = "usa.canon.com"
+    domain_ca = "canon.ca"
+    product_url_pattern_us = "usa.canon.com/shop/p/"
+    product_url_pattern_ca = "canon.ca/en/product"
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.region = "us"  # Default region
+        self.retailer = None  # Store retailer info
+        
+    def determine_region(self, retailer: Optional[str]) -> str:
+        """
+        Determine region based on retailer information.
+        
+        Args:
+            retailer: Retailer string that may contain region information
+            
+        Returns:
+            'ca' for Canada, 'us' for United States (default)
+        """
+        if retailer:
+            retailer_lower = retailer.lower()
+            if 'canada' in retailer_lower:
+                return 'ca'
+            elif 'us' in retailer_lower:
+                return 'us'
+        return 'us'  # Default to US if no region found
+        
+    def create_search_query(self, term: str) -> str:
+        """
+        Create region-specific search query.
+        
+        Args:
+            term: Search term (typically product model)
+            
+        Returns:
+            Formatted search query for the appropriate region
+        """
+        # Determine region based on stored retailer info
+        self.region = self.determine_region(self.retailer)
+        domain = self.domain_ca if self.region == 'ca' else self.domain_us
+        return f"site:{domain} {term}"
+    
+    async def parse(self, url: str, search_term: str, retailer: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Parse product information from a Canon URL using Selenium.
+        
+        Args:
+            url: Canon product URL
+            search_term: Original search term
+            retailer: Optional retailer information to determine region
+            
+        Returns:
+            Dictionary with product information
+        """
+        self.retailer = retailer  # Store retailer info for use in other methods
+        self.region = self.determine_region(retailer)
+        
+        result = {
+            "source_url": url,
+            "search_term": search_term,
+            "model_code": None,
+            "product_name": None,
+            "price": None,
+            "specs": None,
+            "images": None,
+            "parse_status": "pending",
+            "region": self.region
+        }
+        
+        try:
+            self.headless = True
+            driver = await self.get_driver()
+            await self.get_page(url)
+            
+            page_content = driver.page_source
+            soup = BeautifulSoup(page_content, "html.parser")
+            
+            if self.region == 'ca':
+                # Selectores para el sitio de Canadá
+                # Extract model code - usando un selector más robusto
+                model_elem = soup.select_one("p[class*='ItemCode']")  # Busca cualquier p que contenga 'ItemCode' en su clase
+                if not model_elem:
+                    # Alternativa: buscar por el texto "Item Code" y navegar a su contenido
+                    model_elems = soup.find_all(string=lambda text: text and "Item Code" in text)
+                    if model_elems:
+                        # Encontrar el elemento padre y extraer el texto completo
+                        model_elem = model_elems[0].parent
+                
+                if model_elem:
+                    # Obtener el texto y limpiarlo
+                    model_text = model_elem.text.strip()
+                    # Eliminar "Item Code:" y cualquier espacio extra
+                    model_text = model_text.replace("Item Code: ", "").strip()
+                    result["model_code"] = model_text
+                
+                # Extract product name
+                name_elem = soup.select_one("h1.ProductName")  # Ajustar según el sitio real
+                if name_elem:
+                    result["product_name"] = name_elem.text.strip()
+                
+            else:
+                # Selectores para el sitio de USA
+                product_name_elem = soup.select_one("span.base[data-ui-id='page-title-wrapper'][itemprop='name']")
+                if product_name_elem:
+                    result["product_name"] = product_name_elem.text.strip()
+                
+                sku_elem = soup.select_one("div.value[itemprop='sku']")
+                if sku_elem:
+                    result["model_code"] = sku_elem.text.strip()
+            
+            # Extract price (común para ambos sitios, ajustar si es necesario)
+            price_elem = soup.select_one("[data-price-type='finalPrice'] .price")
+            if price_elem:
+                result["price"] = price_elem.text.strip()
+            
+            # Extract image (común para ambos sitios, ajustar si es necesario)
+            main_img = soup.select_one("img[data-role='product-image']")
+            if main_img:
+                src = main_img.get("src")
+                if src:
+                    domain = self.domain_ca if self.region == 'ca' else self.domain_us
+                    if not src.startswith(("http://", "https://")):
+                        src = f"https://{domain}{src}" if src.startswith("/") else f"https://{domain}/{src}"
+                    result["images"] = [src]
+            
+            result["parse_status"] = "success"
+            
+        except Exception as e:
+            self._logger.error(f"Error parsing Canon product: {str(e)}")
+            result["parse_status"] = f"error: {str(e)}"
+        finally:
+            self.close_driver()
+            
+        return result
+
+    def get_product_urls(self, search_results: List[Dict[str, str]], max_urls: int = 5) -> List[str]:
+        """
+        Extract relevant product URLs from search results.
+        
+        Args:
+            search_results: List of search result dictionaries
+            max_urls: Maximum number of URLs to return
+            
+        Returns:
+            List of product URLs that match the Canon product pattern
+        """
+        urls = []
+        pattern = self.product_url_pattern_ca if self.region == 'ca' else self.product_url_pattern_us
+        domain = self.domain_ca if self.region == 'ca' else self.domain_us
+        
+        for result in search_results[:max_urls]:
+            url = result.get('link') or result.get('href') or result.get('url')
+            if url and domain in url and pattern in url:
+                urls.append(url)
+        return urls 

flowtask/components/ProductInfo/parsers/epson.py

@@ -0,0 +1,118 @@
+import re
+from typing import Dict, Any, Optional
+import httpx
+from bs4 import BeautifulSoup
+from .base import ParserBase
+
+class EpsonParser(ParserBase):
+    """
+    Parser for Epson product information.
+    
+    Extracts product details from Epson's website.
+    """
+    domain = "epson.com"
+    search_format = "site:epson.com {} product"
+    model_pattern = r"^.*\/\b[p|s]\/([^?]+)"
+    
+    def extract_model_code(self, url: str) -> Optional[str]:
+        """
+        Extract model code from URL using the regex pattern and clean it.
+        
+        Args:
+            url: URL to extract model code from
+            
+        Returns:
+            Cleaned model code or None if not found
+        """
+        match = re.search(self.model_pattern, url)
+        if match and match.group(1):
+            # Extraer el código
+            model_code = match.group(1)
+            
+            # Limpiar el prefijo SPT_ si existe
+            if model_code.startswith("SPT_"):
+                model_code = model_code.replace("SPT_", "", 1)
+                
+            return model_code
+        return None
+    
+    async def parse(self, url: str, search_term: str, retailer: str = None) -> Dict[str, Any]:
+        """
+        Parse product information from an Epson URL.
+        
+        Args:
+            url: Epson product URL
+            search_term: Original search term
+            retailer: Optional retailer information
+            
+        Returns:
+            Dictionary with product information
+        """
+        result = {
+            "source_url": url,
+            "search_term": search_term,
+            "model_code": self.extract_model_code(url),
+            "product_name": None,
+            "price": None,
+            "description": None,
+            "specs": None,
+            "images": None,
+            "parse_status": "pending"
+        }
+        
+        try:
+            # Get the page content
+            response = await self._get(url, headers=self.headers, use_proxy=True)
+            if not response or response.status_code != 200:
+                result["parse_status"] = f"error: HTTP {response.status_code if response else 'no response'}"
+                return result
+                
+            # Parse the HTML
+            soup = BeautifulSoup(response.text, "html.parser")
+            
+            # Extract product name
+            product_name_elem = soup.select_one("h1.product-name, h1.product-title")
+            if product_name_elem:
+                result["product_name"] = product_name_elem.text.strip()
+            
+            # Extract price
+            price_elem = soup.select_one("span.price, div.product-price")
+            if price_elem:
+                result["price"] = price_elem.text.strip()
+            
+            # Extract description
+            desc_elem = soup.select_one("div.product-description, div.product-overview")
+            if desc_elem:
+                result["description"] = desc_elem.text.strip()
+            
+            # Extract specifications
+            specs = {}
+            specs_section = soup.select_one("div.product-specifications, div.tech-specs")
+            if specs_section:
+                for row in specs_section.select("tr, div.spec-row"):
+                    label = row.select_one("th, .spec-label")
+                    value = row.select_one("td, .spec-value")
+                    if label and value:
+                        specs[label.text.strip()] = value.text.strip()
+                result["specs"] = specs
+            
+            # Extract images
+            image_urls = []
+            for img in soup.select("div.product-gallery img, img.product-image"):
+                src = img.get("src") or img.get("data-src")
+                if src:
+                    if not src.startswith(("http://", "https://")):
+                        src = f"https://{self.domain}{src}" if src.startswith("/") else f"https://{self.domain}/{src}"
+                    image_urls.append(src)
+            if image_urls:
+                result["images"] = image_urls
+            
+            result["parse_status"] = "success"
+            
+        except httpx.RequestError as e:
+            result["parse_status"] = f"error: request failed - {str(e)}"
+        except Exception as e:
+            self._logger.error(f"Error parsing Epson product: {str(e)}")
+            result["parse_status"] = f"error: {str(e)}"
+            
+        return result 

flowtask/components/ProductInfo/parsers/hp.py

@@ -0,0 +1,131 @@
+import re
+import asyncio
+from typing import Dict, Any, Optional, List
+import httpx
+from bs4 import BeautifulSoup
+from .base import ParserBase
+
+class HPParser(ParserBase):
+    """
+    Parser for HP product information.
+    
+    Extracts product details from HP's website using Selenium for dynamic content.
+    """
+    domain = "hp.com"
+    search_format = "site:hp.com {}"  # Sin la palabra 'product' como en Epson
+    product_url_pattern = "hp.com/us-en/shop/pdp/"  # Patrón para URLs de producto válidas
+    
+    async def parse(self, url: str, search_term: str, retailer: str = None) -> Dict[str, Any]:
+        """
+        Parse product information from an HP URL using Selenium.
+        
+        Args:
+            url: HP product URL
+            search_term: Original search term
+            
+        Returns:
+            Dictionary with product information
+        """
+        result = {
+            "source_url": url,
+            "search_term": search_term,
+            "model_code": None,
+            "product_name": None,
+            "price": None,
+            "specs": None,
+            "images": None,
+            "parse_status": "pending"
+        }
+        
+        try:
+            # Utilizamos Selenium ya que la página de HP tiene contenido dinámico
+            driver = await self.get_driver()
+            await self.get_page(url)
+            
+            # Ejecutamos un scroll para cargar todo el contenido
+            self._execute_scroll(scroll_pause_time=1.5, max_scrolls=5)
+            
+            # Extraer contenido de la página
+            page_content = driver.page_source
+            soup = BeautifulSoup(page_content, "html.parser")
+            
+            # 1. Extract product name - usando el selector exacto de la captura
+            product_name_elem = soup.select_one("h1[data-test-hook='@hpstellar/core/typography']")
+            if product_name_elem:
+                result["product_name"] = product_name_elem.text.strip()
+            
+            # 2. Extract price - directamente desde el atributo data-widget-item-price
+            price_attr_elem = soup.select_one("[data-widget-item-price]")
+            if price_attr_elem:
+                price_value = price_attr_elem.get("data-widget-item-price")
+                if price_value:
+                    result["price"] = f"${price_value}"
+            # Si no se encuentra con el atributo, intentar con el selector de la captura
+            elif not result["price"]:
+                price_elem = soup.select_one("span[data-test-hook='@hpstellar/core/typography'][class*='sale-subscription-price']")
+                if price_elem:
+                    result["price"] = price_elem.text.strip()
+                      
+            # 4. Extract model code - directamente desde el atributo data-widget-item-sku
+            sku_elem = soup.select_one("[data-widget-item-sku]")
+            if sku_elem:
+                result["model_code"] = sku_elem.get("data-widget-item-sku")
+            
+            # Si no se encontró el código en el atributo, intentar con span.sku
+            if not result["model_code"]:
+                model_elem = soup.select_one("span.sku")
+                if model_elem:
+                    text = model_elem.text.strip()
+                    # Eliminar el prefijo "Product #" si está presente
+                    if "Product #" in text:
+                        result["model_code"] = text.replace("Product # ", "").strip()
+                    else:
+                        result["model_code"] = text
+            
+            # 5. Extract SINGLE product image - usando el selector exacto de la captura
+            # Intentar primero con el botón específico
+            main_img = soup.select_one("button[data-gtm-category='linkClick'][data-gtm-id='gallery'] img")
+            
+            # Si no encuentra con ese selector, probar con el otro selector visible en las capturas
+            if not main_img:
+                main_img = soup.select_one("[data-test-hook='@hpstellar/core/image-with-placeholder'] img")
+            
+            if main_img:
+                src = main_img.get("src") or main_img.get("data-src")
+                if src:
+                    # Asegurar que la URL sea absoluta
+                    if not src.startswith(("http://", "https://")):
+                        src = f"https://{self.domain}{src}" if src.startswith("/") else f"https://{self.domain}/{src}"
+                    result["images"] = [src]  # Guardamos una sola imagen como lista
+            
+            result["parse_status"] = "success"
+            
+        except httpx.RequestError as e:
+            result["parse_status"] = f"error: request failed - {str(e)}"
+        except Exception as e:
+            self._logger.error(f"Error parsing HP product: {str(e)}")
+            result["parse_status"] = f"error: {str(e)}"
+        finally:
+            # Asegurar que cerramos el driver
+            self.close_driver()
+            
+        return result 
+
+    def get_product_urls(self, search_results: List[Dict[str, str]], max_urls: int = 5) -> List[str]:
+        """
+        Extract relevant product URLs from search results.
+        
+        Args:
+            search_results: List of search result dictionaries
+            max_urls: Maximum number of URLs to return
+            
+        Returns:
+            List of product URLs that match the HP product pattern
+        """
+        urls = []
+        for result in search_results[:max_urls]:
+            url = result.get('link') or result.get('href') or result.get('url')
+            # Verificar que la URL sea de una página de producto de HP
+            if url and self.domain in url and self.product_url_pattern in url:
+                urls.append(url)
+        return urls 

flowtask/components/ProductInfo/parsers/samsung.py

@@ -0,0 +1,97 @@
+import re
+from typing import Dict, Any, Optional, List
+from bs4 import BeautifulSoup
+from .base import ParserBase
+
+class SamsungParser(ParserBase):
+    """
+    Parser for Samsung product information.
+    
+    Extracts product details from Samsung's website using Selenium.
+    """
+    domain = "samsung.com"
+    search_format = "site:samsung.com {}"
+    product_url_pattern = "samsung.com/products/"  # Ajustar según la estructura real de URLs
+    
+    async def parse(self, url: str, search_term: str, retailer: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Parse product information from a Samsung URL using Selenium.
+        
+        Args:
+            url: Samsung product URL
+            search_term: Original search term
+            retailer: Optional retailer information (not used for Samsung)
+            
+        Returns:
+            Dictionary with product information
+        """
+        result = {
+            "source_url": url,
+            "search_term": search_term,
+            "model_code": None,
+            "product_name": None,
+            "price": None,
+            "specs": None,
+            "images": None,
+            "parse_status": "pending"
+        }
+        
+        try:
+            self.headless = True
+            driver = await self.get_driver()
+            await self.get_page(url)
+            
+            page_content = driver.page_source
+            soup = BeautifulSoup(page_content, "html.parser")
+            
+            # Extract model code - usando el selector exacto de la captura
+            model_elem = soup.select_one('span[data-testid="atom_label"]')
+            if model_elem:
+                result["model_code"] = model_elem.text.strip()
+            
+            # Extract product name - usando el selector exacto de la captura
+            name_elem = soup.select_one("div[class*='ProductTitle_product']")
+            if name_elem:
+                result["product_name"] = name_elem.text.strip()
+            
+            # Extract price (ajustar según el sitio real)
+            price_elem = soup.select_one("span.price")  # Ajustar según el sitio real
+            if price_elem:
+                result["price"] = price_elem.text.strip()
+            
+            # Extract image (ajustar según el sitio real)
+            main_img = soup.select_one("img.product-image")  # Ajustar según el sitio real
+            if main_img:
+                src = main_img.get("src")
+                if src:
+                    if not src.startswith(("http://", "https://")):
+                        src = f"https://{self.domain}{src}" if src.startswith("/") else f"https://{self.domain}/{src}"
+                    result["images"] = [src]
+            
+            result["parse_status"] = "success"
+            
+        except Exception as e:
+            self._logger.error(f"Error parsing Samsung product: {str(e)}")
+            result["parse_status"] = f"error: {str(e)}"
+        finally:
+            self.close_driver()
+            
+        return result
+
+    def get_product_urls(self, search_results: List[Dict[str, str]], max_urls: int = 1) -> List[str]:  # Cambiado a 1 para tomar solo el primer resultado
+        """
+        Extract relevant product URLs from search results.
+        
+        Args:
+            search_results: List of search result dictionaries
+            max_urls: Maximum number of URLs to return (default: 1)
+            
+        Returns:
+            List of product URLs that match the Samsung product pattern
+        """
+        urls = []
+        for result in search_results[:max_urls]:
+            url = result.get('link') or result.get('href') or result.get('url')
+            if url and self.domain in url:  # Menos restrictivo con el patrón de URL
+                urls.append(url)
+        return urls