xhs-note-extractor 0.1.dev6__py3-none-any.whl → 0.1.4__py3-none-any.whl

xhs_note_extractor/extractor.py

@@ -20,6 +20,10 @@ from typing import Dict, List, Optional, Union
 from urllib.parse import urlparse, parse_qs
 import xml.etree.ElementTree as ET
 
+# 延迟加载agent_login模块以避免不必要的依赖
+from .date_desc_utils import parse_time_to_timestamp_ms
+from .number_utils import parse_count_to_int
+
 # 配置日志
 logging.basicConfig(
     level=logging.INFO,
@@ -36,23 +40,64 @@ class XHSNoteExtractor:
     包括URL解析、设备连接、页面跳转和笔记内容提取。
     """
     
-    def __init__(self, device_serial: Optional[str] = None, enable_time_logging: bool = True):
+    def __init__(self, devices:dict = None):
         """
         初始化小红书笔记提取器
         
         Args:
-            device_serial (str, optional): 设备序列号，如果为None则自动连接可用设备
-            enable_time_logging (bool, optional): 是否启用耗时打印，默认为True
-            
+            devices (dict, optional): 设备信息字典，包含设备序列号和对应小红书账号可选手机号
+            {
+                "b520805": ["13800000000"]
+            }
+        
         Raises:
-            RuntimeError: 当没有可用设备时抛出异常
+            ValueError: 当设备信息为空或无效时抛出异常
         """
-        self.device = None
-        self.device_serial = device_serial
-        self.enable_time_logging = enable_time_logging
-        if not self.connect_device():
-            raise RuntimeError("未找到可用的Android设备，请连接设备后再试")
+        if not devices:
+            raise ValueError("设备信息必须从外部传入")
+        
+        self.device = None # 当前设备
+        self.next_phone = None # 下一个手机号
+        self.devices_info = devices  # 存储设备信息字典
+        self.problematic_devices = []  # 存储无法获取笔记的设备信息
+        self.enable_time_logging = True  # 默认启用耗时打印
+        
+        # 日志记录设备信息
+        logger.info(f"已配置设备信息: {self.devices_info}")
+        logger.info("设备将在需要时连接")
     
+    def _get_next_phone_number(self, device_serial: str) -> Optional[str]:
+        """
+        获取指定设备的下一个手机号（循环）
+        
+        Args:
+            device_serial (str): 设备序列号
+            
+        Returns:
+            str: 下一个手机号，如果没有则返回None
+        """
+        if device_serial not in self.devices_info:
+            return None
+        
+        phone_list = self.devices_info[device_serial]
+        if not phone_list:
+            return None
+        
+        # 如果当前没有设置下一个手机号，返回第一个
+        if not self.next_phone:
+            self.next_phone = phone_list[0]
+            return self.next_phone
+        
+        # 找到当前手机号在列表中的索引
+        try:
+            current_index = phone_list.index(self.next_phone)
+            # 循环到下一个
+            next_index = (current_index + 1) % len(phone_list)
+            self.next_phone =  phone_list[next_index]
+        except ValueError:
+            # 如果当前手机号不在列表中，返回第一个
+            self.next_phone = phone_list[0]
+        return self.next_phone
     def _time_method(self, method_name, start_time):
         """
         记录方法执行时间
@@ -63,28 +108,92 @@ class XHSNoteExtractor:
         """
         if self.enable_time_logging:
             elapsed_time = time.time() - start_time
-            logger.info(f"[{method_name}] 耗时: {elapsed_time:.3f}秒")
+            if elapsed_time < 1:
+                logger.info(f"⏱️  [{method_name}] 耗时: {elapsed_time*1000:.0f}ms")
+            else:
+                logger.info(f"⏱️  [{method_name}] 耗时: {elapsed_time:.2f}s")
+    
+
     
-    def connect_device(self) -> bool:
+    def connect_device(self, device_serial: Optional[str] = None) -> bool:
         """
         连接设备
         
+        Args:
+            device_serial (str, optional): 指定设备序列号，如果为None则使用devices_info中的第一个设备
+            
         Returns:
             bool: 是否成功连接设备
         """
         start_time = time.time()
+        
+        # 如果指定了设备序列号，则使用指定的设备
+        target_device = device_serial
+        
+        # 如果没有指定设备序列号，尝试使用devices_info中的第一个设备
+        if not target_device and self.devices_info:
+            target_device = next(iter(self.devices_info.keys()))
+        
         try:
-            if self.device_serial:
-                self.device = u2.connect(self.device_serial)
-            else:
-                self.device = u2.connect()
+            if not target_device:
+                logger.error("✗ 设备连接失败: 无法确定设备序列号")
+                self._time_method("connect_device", start_time)
+                return False
+            
+            self.device = u2.connect(target_device)
             logger.info(f"✓ 已连接设备: {self.device.serial}")
             self._time_method("connect_device", start_time)
+            # 重启小红书应用以确保登录状态
+            logger.info("🔄 重启小红书应用...")
+            self.device.app_stop("com.xingin.xhs")
+            time.sleep(1)
+            self.device.app_start("com.xingin.xhs")
+            time.sleep(3)
+            # 获取下一个手机号
+            self.next_phone = self._get_next_phone_number(target_device)
+            logger.warning(f'next_phone:{self.next_phone}')
             return True
         except Exception as e:
             logger.error(f"✗ 设备连接失败: {e}")
             self._time_method("connect_device", start_time)
             return False
+    
+    def switch_to_next_device(self) -> bool:
+        """
+        切换到下一个可用设备
+        
+        Returns:
+            bool: 是否成功切换到下一个设备
+        """
+        self.next_phone = None # 重置下一个手机号为None
+        if not self.devices_info or len(self.devices_info) <= 1:
+            logger.warning("没有更多可用设备可以切换")
+            return False
+        
+        # 获取当前设备的序列号
+        current_serial = self.device.serial if self.device else None
+        logger.info(f"当前设备: {current_serial}")
+        # 转换为列表以便切换
+        device_serials = list(self.devices_info.keys())
+        logger.info(f"device_serials: {device_serials}")
+        # 找到当前设备的索引
+        current_index = device_serials.index(current_serial) if current_serial in device_serials else -1
+        logger.info(f"current_index: {current_index}")
+        
+        # 如果当前设备不在列表中，并且有尝试过的设备记录，则从尝试过的设备之后开始
+        attempted_serials = [d['serial'] for d in self.problematic_devices]
+        if current_index == -1 and attempted_serials:
+            # 找到最后一个尝试过的设备的索引
+            last_attempted = attempted_serials[-1]
+            if last_attempted in device_serials:
+                current_index = device_serials.index(last_attempted)
+        
+        # 移动到下一个设备
+        next_index = (current_index + 1) % len(device_serials)
+        next_device_serial = device_serials[next_index]
+        logger.info(f"next_device_serial: {next_device_serial}")
+        logger.info(f"尝试切换到设备: {next_device_serial}")
+        return self.connect_device(next_device_serial)
     def is_device_connected(self) -> bool:
         """
         检查设备是否仍然连接
@@ -100,7 +209,71 @@ class XHSNoteExtractor:
             return True
         except:
             return False
+    
+    def get_problematic_devices(self) -> List[Dict[str, Union[str, float]]]:
+        """
+        获取无法获取笔记的设备列表
+        
+        Returns:
+            List[Dict[str, Union[str, float]]]: 包含有问题设备信息的列表，每个设备信息包括：
+                - serial: 设备序列号
+                - reason: 问题原因
+                - note_id: 尝试提取的笔记ID
+                - timestamp: 记录时间戳
+        """
+        return self.problematic_devices
+    
+    def clear_problematic_devices(self) -> None:
+        """
+        清空有问题的设备列表
+        """
+        self.problematic_devices.clear()
+    # 清除缓存并重启APP
+    def clear_login_state(self, device_serial=None):
+        import uiautomator2 as u2
+        import time
+
+        # 连接设备
+        d = u2.connect(device_serial)
+
+        # 启动APP
+        d.app_stop('com.xingin.xhs')
+        time.sleep(1)  # 等待APP启动
+        d.app_start('com.xingin.xhs')
+        time.sleep(2)  # 等待APP启动
+        try:
+            if not d(text='我').exists():
+                print("已退出登录，无需退出登录")
+                return
+                
+            # 点击我的/个人中心按钮
+            d(description='我').click()
+            time.sleep(2)
+
+            if d(text='微信登录').exists() or d(text='手机号登录').exists():
+                print("已登录，无需退出登录")
+                return
 
+            # 点击设置按钮
+            d(description='设置').click()
+            time.sleep(2)
+            
+            # 滚动到退出登录选项
+            d.swipe_ext('up', scale=0.5)
+            time.sleep(1)
+            
+            # 点击退出登录
+            d(text='退出登录').click()
+            time.sleep(1)
+            
+            # 确认退出
+            d(text='退出登录').click()
+            time.sleep(2)
+            
+            print("退出登录成功")
+        except Exception as e:
+            print(f"退出登录失败: {e}")
+    
     @staticmethod
     def parse_xhs_url(url: str) -> Dict[str, str]:
         """
@@ -225,10 +398,10 @@ class XHSNoteExtractor:
         logger.info(f"[convert_to_xhsdiscover_format] 耗时: {elapsed_time:.3f}秒")
         return result
     
-    def extract_note_data(self, url: Optional[str] = None, note_id: Optional[str] = None, 
-                         xsec_token: Optional[str] = None) -> Dict[str, Union[str, List[str]]]:
+    def extract_note_data(self, url: Optional[str] = None, note_id: Optional[str] = None,
+                         xsec_token: Optional[str] = None) -> Optional[Dict[str, Union[str, List[str]]]]:
         """
-        从小红书笔记中提取数据
+        从小红书笔记中提取数据，支持设备重试机制
         
         Args:
             url (str, optional): 小红书URL，如果提供则会解析其中的note_id和xsec_token
@@ -236,10 +409,9 @@ class XHSNoteExtractor:
             xsec_token (str, optional): xsec_token参数
             
         Returns:
-            Dict[str, Union[str, List[str]]]: 包含笔记数据的字典，格式与xhs_utils.get_detail_data()一致
+            Optional[Dict[str, Union[str, List[str]]]]: 包含笔记数据的字典，如果没有成功则返回None
             
         Raises:
-            RuntimeError: 当设备未连接时抛出异常
             Exception: 当提取过程中出现错误时抛出异常
         """
         start_time = time.time()
@@ -248,40 +420,129 @@ class XHSNoteExtractor:
             parsed_data = self.parse_xhs_url(url)
             note_id = parsed_data["note_id"]
             xsec_token = parsed_data["xsec_token"]
-            
-        # 检查设备是否连接
-        if self.device is None:
-            self._time_method("extract_note_data", start_time)
-            raise RuntimeError("设备未连接，请先连接设备")
         
-        # 构建跳转URL
-        jump_url = self.convert_to_xhsdiscover_format(note_id, xsec_token)
+        max_retries = len(self.devices_info) if self.devices_info else 1
+        attempted_devices = []
         
-        logger.info(f"正在尝试跳转至笔记: {note_id}")
-        
-        try:
-            # 发起跳转
-            self.device.open_url(jump_url)
-            logger.info("✓ 已发送跳转指令，等待页面加载...")
+        for attempt in range(max_retries):
+            logger.info(f"尝试第 {attempt + 1}/{max_retries} 次提取笔记: {note_id}")
             
-            # 使用现有的xhs_utils功能提取数据
-            data = self._get_detail_data()
+            # 检查设备是否连接，如果没有则尝试连接
+            if self.device is None:
+                if not self.connect_device():
+                    logger.warning("设备连接失败，尝试下一个设备")
+                    # 记录连接失败的设备
+                    device_serials = list(self.devices_info.keys())
+                    if device_serials and attempt < len(device_serials):
+                        failed_device = device_serials[attempt]
+                        if failed_device not in [d['serial'] for d in self.problematic_devices]:
+                            self.problematic_devices.append({
+                                'serial': failed_device,
+                                'reason': '设备连接失败',
+                                'note_id': note_id,
+                                'timestamp': time.time()
+                            })
+                    if self.switch_to_next_device():
+                        continue
+                    else:
+                        break
             
-            logger.info(f"✓ 成功提取笔记数据，点赞数: {data['likes']}, 图片数: {len(data['image_urls'])}")
+            # 构建跳转URL
+            jump_url = self.convert_to_xhsdiscover_format(note_id, xsec_token)
             
-            self._time_method("extract_note_data", start_time)
-            return data
+            logger.info(f"正在尝试跳转至笔记: {note_id} (设备: {self.device.serial if self.device else '未知'})")
             
-        except Exception as e:
-            logger.error(f"✗ 提取笔记数据失败: {e}")
-            self._time_method("extract_note_data", start_time)
-            raise
+            try:
+                # # 在跳转链接前重启APP
+                # logger.info(f"🔄 准备跳转至笔记 {note_id}，正在重启APP...")
+                # self.restart_xhs_app()
+                
+                # 发起跳转
+                self.device.open_url(jump_url)
+                logger.info("✓ 已发送跳转指令，等待页面加载...")
+                
+                # 使用现有的xhs_utils功能提取数据
+                data = self._get_detail_data(jump_url)
+                
+                # 如果返回None，说明需要登录，尝试下一个设备
+                if data is None:
+                    logger.warning(f"当前设备{self.device.serial}需要登录，尝试切换到下一个设备")
+                    attempted_devices.append(self.device.serial if self.device else "未知设备")
+                    # 尝试重新登录
+                    # 触发退出登录
+                    self.clear_login_state(self.device.serial)
+                    # 触发登录
+                    # 确认当前设备对应的手机号                 
+                    self.next_phone = self._get_next_phone_number(self.device.serial)
+                    logger.warning(f'next_phone:{self.next_phone}')
+                    try:
+                        # 延迟加载agent_login模块以避免不必要的依赖
+                        from .agent_login import do_login
+                        if do_login(phone_number=self.next_phone, device_id=self.device.serial):
+                            logger.info(f"✓ 设备{self.device.serial}登录成功")
+                            continue
+                        else:
+                            logger.warning(f"✓ 设备{self.device.serial}登录失败")
+                            attempted_devices.append(self.device.serial)  # 记录尝试过的设备
+                            # 保存当前设备序列号，以便switch_to_next_device知道从哪里开始
+                            failed_device_serial = self.device.serial
+                            self.device = None
+                            
+                            # 手动记录失败的设备信息
+                            if failed_device_serial not in [d['serial'] for d in self.problematic_devices]:
+                                self.problematic_devices.append({
+                                    'serial': failed_device_serial,
+                                    'reason': '设备登录失败',
+                                    'note_id': note_id,
+                                    'timestamp': time.time()
+                                })
+                            
+                            # 尝试切换到下一个设备
+                            if not self.switch_to_next_device():
+                                logger.error("没有更多可用设备，提取失败")
+                                self._time_method("extract_note_data", start_time)
+                                return {}
+                            continue
+                    except ImportError as e:
+                        logger.warning(f"无法导入登录模块: {e}")
+                        logger.warning("将尝试跳过登录步骤，继续使用当前设备")
+                        continue
+                    
+                logger.info(f"✓ 成功提取笔记数据，点赞数: {data['likes']}, 图片数: {len(data['image_urls'])}")
+                self._time_method("extract_note_data", start_time)
+                return data
+                
+            except Exception as e:
+                logger.error(f"✗ 提取笔记数据失败: {e}")
+                attempted_devices.append(self.device.serial if self.device else "未知设备")
+                
+                # 记录有问题的设备
+                if self.device and self.device.serial not in [d['serial'] for d in self.problematic_devices]:
+                    self.problematic_devices.append({
+                        'serial': self.device.serial,
+                        'reason': f'提取异常: {str(e)}',
+                        'note_id': note_id,
+                        'timestamp': time.time()
+                    })
+                
+                # 如果还有设备可用，尝试下一个
+                if attempt < max_retries - 1 and self.switch_to_next_device():
+                    continue
+                else:
+                    logger.error("所有设备尝试完毕，提取失败")
+                    self._time_method("extract_note_data", start_time)
+        logger.error(f"所有设备尝试完毕，提取失败。尝试过的设备: {attempted_devices}")
+        self._time_method("extract_note_data", start_time)
+        return {}
     
-    def _get_detail_data(self) -> Dict[str, Union[str, List[str]]]:
+    def _get_detail_data(self, jump_url: str) -> Dict[str, Union[str, List[str]]]:
         """
         从当前已经打开的小红书详情页提取完整正文、图片和点赞数。
         优化版本: 使用 dump_hierarchy 替代遍历，大幅提升速度。
         
+        Args:
+            jump_url (str): 笔记的跳转URL，用于白屏时重新加载
+            
         Returns:
             Dict[str, Union[str, List[str]]]: 包含笔记数据的字典
         """
@@ -290,131 +551,245 @@ class XHSNoteExtractor:
         
         # 1. 验证是否进入详情页 & 展开全文
         detail_loaded = False
-        detail_keywords = ["说点什么", "写评论", "写点什么", "收藏", "点赞", "评论", "分享", "发弹幕"]
-        
-        # 尝试点击展开 (预先动作)
         try:
-            # 快速检查是否有展开按钮
-            for btn_text in ["展开", "查看全部", "全文"]:
-                if self.device(text=btn_text).exists:
-                    self.device(text=btn_text).click()
-                    break
+            if self.device(text="展开").exists:
+                self.device(text="展开").click()
         except: pass
 
-        # 等待加载完整
-        for i in range(5):
-            if any(self.device(textContains=kw).exists or self.device(descriptionContains=kw).exists for kw in detail_keywords):
-                detail_loaded = True
-                break
-            if i == 2:
-                # 可能是视频，点击屏幕中心尝试激活 UI
-                self.device.click(540, 900)
-            time.sleep(0.5)
+        # 超快速检查 - 只等0.2秒
+        time.sleep(0.2)
         
-        if not detail_loaded:
-            logger.warning("⚠ 警告：详情页特征未发现，提取可能不完整")
-
-        # 2. 获取 UI层级 (核心优化)
-        xml_dump_start = time.time()
-        xml_content = self.device.dump_hierarchy()
-        self._time_method("dump_hierarchy", xml_dump_start)
+        # 快速检查登录状态
+        if self.device(textContains="其他登录方式").exists or self.device(textContains="微信登录").exists or self.device(textContains="登录发现更多精彩").exists:
+            logger.error("✗ 需要登录才能查看详情页内容，提取终止")
+            return None
         
-        # 3. 解析 XML
-        root = ET.fromstring(xml_content)
+        # 极简检查 - 只检查一次
+        time.sleep(0.3)
+        detail_count = 5
+        detail_loaded = False
+        while(detail_count > 0):
+            if not self.device(textContains="关注").exists:
+                detail_count -= 1
+                time.sleep(0.1)
+                continue
+            detail_loaded = True
+            break    
         
+        if not detail_loaded:
+            logger.warning("⚠ 警告:详情页特征未发现,提取可能不完整")
+
+        # 智能滚动 - 确保看到发布时间和评论区 (优化速度版)
+        scroll_phase_start = time.time()
+        try:
+            # 定义需要查找的目标元素 (正则匹配)
+            target_pattern = re.compile(r"条评论|发布于|小时前|天前|月前|年前|昨天|今天")
+            
+            # 最多滚动6次，单次距离加大
+            for i in range(6):
+                # 向下滚动
+                swipe_start = time.time()
+                self.device.swipe(540, 1600, 540, 600, 0.1)
+                self._time_method(f"scroll_swipe_{i+1}", swipe_start)
+                
+                # 核心优化：只 dump 一次，在字符串中搜索，避免多次 exists() 调用的开销
+                dump_start = time.time()
+                xml_temp = self.device.dump_hierarchy()
+                self._time_method(f"scroll_dump_{i+1}", dump_start)
+                
+                if target_pattern.search(xml_temp):
+                    logger.info(f"✓ 已检测到目标元素 (第 {i+1} 次滚动)")
+                    break
+                
+                # 极短间隔
+                time.sleep(0.1)
+            
+            time.sleep(0.3)  # 稳定时间
+            self._time_method("intelligent_scroll_total", scroll_phase_start)
+            logger.info("✓ 滚动完成")
+        except Exception as e:
+            logger.warning(f"滚动失败: {e}")
+
+        # 初始化提取变量
         content = ""
-        likes = "0"
-        collects = "0"
-        comments = "0"
+        likes = 0
+        collects = 0
+        comments = 0
         author_name = "Unknown"
+        publish_time = 0
+        date_desc = ""
         image_urls = []
         
-        # 收集所有 TextView 节点信息
+        # 2. 获取 UI层级 (核心优化)
+        # 增加一次重试逻辑，如果第一次没抓到日期
         text_nodes = []
+        limit_y = 2500
         
-        def parse_nodes(node):
-            if node.attrib.get('class') == 'android.widget.TextView':
-                text = node.attrib.get('text', '')
+        for attempt in range(2):
+            xml_dump_start = time.time()
+            xml_content = self.device.dump_hierarchy()
+            self._time_method("dump_hierarchy", xml_dump_start)
+            
+            # 检测白屏状态 - 检查文本节点数量
+            current_text_nodes = []
+            root = ET.fromstring(xml_content)
+            
+            def parse_nodes(node):
+                text = node.attrib.get('text', '') or node.attrib.get('content-desc', '')
                 bounds_str = node.attrib.get('bounds', '[0,0][0,0]')
-                # 解析 bounds: [x1,y1][x2,y2]
                 try:
                     coords = bounds_str.replace('][', ',').replace('[', '').replace(']', '').split(',')
                     x1, y1, x2, y2 = map(int, coords)
                     if text:
-                        text_nodes.append({
+                        current_text_nodes.append({
                             'text': text,
                             'l': x1, 't': y1, 'r': x2, 'b': y2,
                             'cx': (x1 + x2) / 2, 'cy': (y1 + y2) / 2
                         })
                 except: pass
-            for child in node:
-                parse_nodes(child)
+                for child in node: parse_nodes(child)
+            
+            parse_nodes(root)
+            
+            # 白屏检测：如果文本节点太少，可能是白屏
+            print(f'当前文本节点数量: {len(current_text_nodes)}')
+            if len(current_text_nodes) < 11:
+                logger.error(f"✗ 检测到白屏状态 - 文本节点数量异常少 ({len(current_text_nodes)}个节点)")
+                logger.info("--- 调试: 捕获的文本节点 ---")
+                for i, n in enumerate(current_text_nodes):
+                    logger.info(f"[{i}] {n['text']} (t={n['t']}, b={n['b']}, l={n['l']}, r={n['r']})")
+                logger.info("--- 调试结束 ---")
                 
-        parse_nodes(root)
-        
-        # 4. 分析节点数据
-        
-        # A. 作者提取 (寻找 "关注" 附近的文本)
-        # 策略: 找到包含 "关注" 的节点，取其左侧最近的节点
-        follow_node = None
-        for n in text_nodes:
-            if n['text'] in ["关注", "已关注"]:
-                follow_node = n
-                break
-        
-        if follow_node:
-            best_dist = 9999
+                # 如果是第一次尝试，重新加载页面
+                if attempt == 0:
+                    logger.info("🔄 尝试重新加载页面...")
+                    # 重新发送跳转指令
+                    self.device.open_url(jump_url)
+                    time.sleep(2)  # 等待页面重新加载
+                    continue
+                else:
+                    # 第二次尝试仍白屏，直接返回None
+                    logger.error("✗ 页面加载失败 - 白屏状态")
+                    return None
+            
+            # 检查是否存在加载指示器
+            loading_found = False
+            for node in current_text_nodes:
+                if re.search(r'(加载|loading|等待|waiting|\.\.\.|\\u231a|\\u25ba)', node['text'], re.IGNORECASE):
+                    loading_found = True
+                    break
+            
+            if loading_found:
+                logger.warning("⚠ 检测到页面正在加载中")
+                if attempt == 0:
+                    logger.info("🔄 等待页面加载完成...")
+                    time.sleep(2)
+                    continue
+            
+            text_nodes = current_text_nodes # 保留最新的节点供后续提取使用
+            
+            # 4. 分析节点数据 (简化版日期快速检查)
+            found_date_in_this_xml = False
+            follow_node = None
             for n in text_nodes:
-                if n == follow_node: continue
-                if n['text'] in ["关注", "已关注"] or len(n['text']) > 30: continue
-                
-                # 垂直接近
-                if abs(n['cy'] - follow_node['cy']) < 100:
-                    # 在左侧
-                    if n['r'] <= follow_node['l'] + 50:
+                if n['text'] in ["关注", "已关注"]:
+                    follow_node = n
+                    break
+            
+            if follow_node:
+                # 寻找作者名
+                best_dist = 999
+                for n in text_nodes:
+                    if n == follow_node: continue
+                    if abs(n['cy'] - follow_node['cy']) < 100 and n['r'] <= follow_node['l'] + 50:
                         dist = follow_node['l'] - n['r']
                         if dist < best_dist:
                             best_dist = dist
                             author_name = n['text']
-            logger.info(f"✓ 识别到作者: {author_name}")
+            
+            # 寻找日期
+            min_y = follow_node['b'] if follow_node else 150
+            # 提前寻找 limit_y
+            current_limit_y = 2500
+            for n in text_nodes:
+                if re.match(r"^共\s*\d+\s*条评论$", n['text']) or n['text'] in ["说点什么", "写评论", "写点什么", "这里是评论区"]:
+                    current_limit_y = min(current_limit_y, n['t'])
+            limit_y = current_limit_y
 
+            for n in text_nodes:
+                if n['t'] > min_y - 200 and n['b'] < limit_y + 150:
+                    txt = n['text'].strip()
+                    if 2 <= len(txt) <= 50 and txt not in ["点赞", "收藏", "评论", "关注", "分享", "回复", "不喜欢"]:
+                        try:
+                            ts = parse_time_to_timestamp_ms(txt)
+                            publish_time = ts
+                            date_desc = txt
+                            found_date_in_this_xml = True
+                            # 不要 break，因为日期通常在最后
+                        except: continue
+            
+            if found_date_in_this_xml:
+                break
+            
+            if attempt == 0:
+                logger.warning("⚠ 未识别到发布时间，尝试额外滚动并重试...")
+                self.device.swipe(540, 1500, 540, 1000, 0.2)
+                time.sleep(0.5)
+
+        if not date_desc:
+            logger.warning("未识别到发布时间")
+            # 埋点调试: 打印出识别到的所有节点及其坐标
+            logger.info("--- 调试: 所有捕获的文本节点 ---")
+            for i, n in enumerate(text_nodes):
+                logger.info(f"[{i}] {n['text']} (t={n['t']}, b={n['b']}, l={n['l']}, r={n['r']})")
+            logger.info("--- 调试结束 ---")
+        else:
+            logger.info(f"✓ 识别到发布时间: {date_desc} -> {publish_time}")
+        
+        logger.info(f"text_nodes: {text_nodes}")
+
+        
         # B. 互动数据提取 (底部区域)
-        bottom_nodes = [n for n in text_nodes if n['t'] > 2000] # 假设屏幕高度足够
+        # 使用 limit_y 作为分割线大概率更准确
+        bottom_nodes = [n for n in text_nodes if n['t'] >= limit_y - 300] # 互动栏通常在 limit_y 上方一点点 或者 就在 mask 区域
         bottom_nodes.sort(key=lambda x: x['l']) # 从左到右
         
         for n in bottom_nodes:
             txt = n['text']
-            num_txt = ''.join(c for c in txt if c.isdigit() or c in ['.', 'w', 'W'])
+            # 保留数字、小数点、w/W 和 "万" 字
+            num_txt = ''.join(c for c in txt if c.isdigit() or c in ['.', 'w', 'W', '万'])
             if not num_txt: continue
             
             cx = n['cx']
             if 500 < cx < 750:
-                likes = num_txt
+                likes = parse_count_to_int(num_txt)
             elif 750 < cx < 900:
-                collects = num_txt
+                collects = parse_count_to_int(num_txt)
             elif cx >= 900:
-                comments = num_txt
+                comments = parse_count_to_int(num_txt)
 
         # C. 正文提取
         # 过滤掉非正文内容
         content_lines = []
-        exclude_keywords = ['收藏', '点赞', '评论', '分享', '发布于', '说点什么', '条评论', '关注', author_name]
+        # exclude_keywords = ['收藏', '点赞', '评论', '分享', '发布于', '说点什么', '条评论', '关注', author_name]
+        # if date_desc:
+        #     exclude_keywords.append(date_desc)
         
-        # 按照垂直位置排序
-        content_nodes = [n for n in text_nodes if 200 < n['t'] < 2000]
+        # 按照垂直位置排序 (使用 min_y 和 limit_y 约束)
+        content_nodes = [n for n in text_nodes if min_y < n['t'] < limit_y]
         content_nodes.sort(key=lambda x: x['t'])
         
         for n in content_nodes:
             t = n['text']
             if len(t) < 2: continue
-            if any(k in t for k in exclude_keywords): continue
+            # if any(k in t for k in exclude_keywords): continue
             
             # 简单的去重策略
             if content_lines and t in content_lines[-1]: continue
             content_lines.append(t)
             
         content = "\n".join(content_lines)
-
+        logger.info(f"提取正文: {content}")
         # 5. 图片提取 (保持原有逻辑但优化等待)
         try:
              # 这里还是需要交互，无法纯靠XML
@@ -443,7 +818,9 @@ class XHSNoteExtractor:
             "likes": likes,
             "collects": collects,
             "comments": comments,
-            "author_name": author_name
+            "author_name": author_name,
+            "publish_time": publish_time,
+            "date_desc": date_desc
         }
     
     def _fetch_web_images(self, url: str) -> List[str]:
@@ -503,6 +880,7 @@ class XHSNoteExtractor:
                 f.write(f"收藏数: {data.get('collects', '0')}\n")
                 f.write(f"评论数: {data.get('comments', '0')}\n")
                 f.write(f"图片数: {len(data.get('image_urls', []))}\n")
+                f.write(f"发布时间: {data.get('date_desc', '')} ({data.get('publish_time', 0)})\n")
                 f.write("=" * 50 + "\n")
                 f.write("【正文内容】\n")
                 f.write(data['content'])
@@ -521,9 +899,9 @@ class XHSNoteExtractor:
             raise
 
 
-def extract_note_from_url(url: str, device_serial: Optional[str] = None, enable_time_logging: bool = True) -> Dict[str, Union[str, List[str]]]:
+def extract_note_from_url(url: str, device_serial: Optional[str] = None, enable_time_logging: bool = True) -> Optional[Dict[str, Union[str, List[str]]]]:
     """
-    便捷函数：直接从URL提取笔记数据
+    便捷函数：直接从URL提取笔记数据，支持设备重试机制
     
     Args:
         url (str): 小红书笔记URL
@@ -531,15 +909,21 @@ def extract_note_from_url(url: str, device_serial: Optional[str] = None, enable_
         enable_time_logging (bool, optional): 是否启用耗时打印，默认为True
         
     Returns:
-        Dict[str, Union[str, List[str]]]: 笔记数据
+        Optional[Dict[str, Union[str, List[str]]]]: 笔记数据，如果没有成功则返回None
     """
     start_time = time.time()
     logger.info(f"[extract_note_from_url] 开始处理URL: {url}")
-    extractor = XHSNoteExtractor(device_serial=device_serial, enable_time_logging=enable_time_logging)
-    result = extractor.extract_note_data(url=url)
-    elapsed_time = time.time() - start_time
-    logger.info(f"[extract_note_from_url] 总耗时: {elapsed_time:.3f}秒")
-    return result
+    try:
+        extractor = XHSNoteExtractor(device_serial=device_serial, enable_time_logging=enable_time_logging)
+        result = extractor.extract_note_data(url=url)
+        elapsed_time = time.time() - start_time
+        logger.info(f"[extract_note_from_url] 总耗时: {elapsed_time:.3f}秒")
+        return result
+    except Exception as e:
+        logger.error(f"[extract_note_from_url] 提取失败: {e}")
+        elapsed_time = time.time() - start_time
+        logger.info(f"[extract_note_from_url] 总耗时: {elapsed_time:.3f}秒")
+        return None
 
 
 def convert_url_format(url: str) -> str: