crawlo 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

crawlo/__version__.py

@@ -1 +1 @@
-__version__ = '1.3.5'
+__version__ = '1.3.7'

crawlo/framework.py

@@ -57,9 +57,10 @@ class CrawloFramework:
 
         self._logger.info(f"Crawlo Framework Started {version}")
         
-        # 获取运行模式并记录日志
+        # 获取运行模式和队列类型并记录日志
         run_mode = self._settings.get('RUN_MODE', 'unknown')
-        self._logger.info(f"Run mode: {run_mode}")
+        queue_type = self._settings.get('QUEUE_TYPE', 'unknown')
+        self._logger.info(f"RunMode: {run_mode}, QueueType: {queue_type}")
         
         # 记录项目名称
         project_name = self._settings.get('PROJECT_NAME', 'unknown')

crawlo/queue/queue_manager.py

@@ -146,6 +146,17 @@ class QueueConfig:
     @classmethod
     def from_settings(cls, settings) -> 'QueueConfig':
         """Create configuration from settings"""
+        # 获取项目名称，用于生成默认队列名称
+        project_name = settings.get('PROJECT_NAME', 'default')
+        default_queue_name = f"crawlo:{project_name}:queue:requests"
+        
+        # 如果设置了SCHEDULER_QUEUE_NAME，则使用该值，否则使用基于项目名称的默认值
+        scheduler_queue_name = settings.get('SCHEDULER_QUEUE_NAME')
+        if scheduler_queue_name is not None:
+            queue_name = scheduler_queue_name
+        else:
+            queue_name = default_queue_name
+        
         return cls(
             queue_type=settings.get('QUEUE_TYPE', QueueType.AUTO),
             redis_url=settings.get('REDIS_URL'),
@@ -153,7 +164,7 @@ class QueueConfig:
             redis_port=settings.get_int('REDIS_PORT', 6379),
             redis_password=settings.get('REDIS_PASSWORD'),
             redis_db=settings.get_int('REDIS_DB', 0),
-            queue_name=settings.get('SCHEDULER_QUEUE_NAME', 'crawlo:requests'),
+            queue_name=queue_name,
             max_queue_size=settings.get_int('SCHEDULER_MAX_QUEUE_SIZE', 1000),
             max_retries=settings.get_int('QUEUE_MAX_RETRIES', 3),
             timeout=settings.get_int('QUEUE_TIMEOUT', 300)
@@ -423,15 +434,23 @@ class QueueManager:
             except ImportError as e:
                 raise RuntimeError(f"Redis队列不可用：未能导入RedisPriorityQueue ({e})")
 
-            # 简化项目名称提取逻辑
+            # 修复项目名称提取逻辑，严格按照测试文件中的逻辑实现
             project_name = "default"
             if ':' in self.config.queue_name:
                 parts = self.config.queue_name.split(':')
-                # 跳过所有"crawlo"前缀，取第一个非"crawlo"部分作为项目名称
-                for part in parts:
-                    if part != "crawlo":
-                        project_name = part
-                        break
+                if len(parts) >= 2:
+                    # 处理可能的双重 crawlo 前缀
+                    if parts[0] == "crawlo" and parts[1] == "crawlo":
+                        # 双重 crawlo 前缀，取"crawlo"作为项目名称
+                        project_name = "crawlo"
+                    elif parts[0] == "crawlo":
+                        # 正常的 crawlo 前缀，取第二个部分作为项目名称
+                        project_name = parts[1]
+                    else:
+                        # 没有 crawlo 前缀，使用第一个部分作为项目名称
+                        project_name = parts[0]
+                else:
+                    project_name = self.config.queue_name or "default"
             else:
                 project_name = self.config.queue_name or "default"
 

crawlo/queue/redis_priority_queue.py

@@ -63,8 +63,8 @@ class RedisPriorityQueue:
         if queue_name is None:
             self.queue_name = f"crawlo:{module_name}:queue:requests"
         else:
-            # 保持用户提供的队列名称不变，不做修改
-            self.queue_name = queue_name
+            # 处理多重 crawlo 前缀，规范化队列名称
+            self.queue_name = self._normalize_queue_name(queue_name)
 
         # 如果未提供 processing_queue，则根据 queue_name 自动生成
         if processing_queue is None:
@@ -92,6 +92,47 @@ class RedisPriorityQueue:
         self._lock = asyncio.Lock()  # 用于连接初始化的锁
         self.request_serializer = RequestSerializer()  # 处理序列化
 
+    def _normalize_queue_name(self, queue_name: str) -> str:
+        """
+        规范化队列名称，处理多重 crawlo 前缀
+        
+        :param queue_name: 原始队列名称
+        :return: 规范化后的队列名称
+        """
+        # 如果队列名称已经符合规范（以 crawlo: 开头且不是 crawlo:crawlo:），则保持不变
+        if queue_name.startswith("crawlo:") and not queue_name.startswith("crawlo:crawlo:"):
+            return queue_name
+            
+        # 处理三重 crawlo 前缀，简化为标准格式
+        if queue_name.startswith("crawlo:crawlo:crawlo:"):
+            # 三重 crawlo 前缀，简化为标准 crawlo: 格式
+            remaining = queue_name[21:]  # 去掉 "crawlo:crawlo:crawlo:" 前缀
+            if remaining:
+                return f"crawlo:{remaining}"
+            else:
+                return "crawlo:requests"  # 默认名称
+                
+        # 处理双重 crawlo 前缀
+        elif queue_name.startswith("crawlo:crawlo:"):
+            # 双重 crawlo 前缀，简化为标准 crawlo: 格式
+            remaining = queue_name[14:]  # 去掉 "crawlo:crawlo:" 前缀
+            if remaining:
+                return f"crawlo:{remaining}"
+            else:
+                return "crawlo:requests"  # 默认名称
+                
+        # 处理无 crawlo 前缀的情况
+        elif not queue_name.startswith("crawlo:"):
+            # 无 crawlo 前缀，添加 crawlo: 前缀
+            if queue_name:
+                return f"crawlo:{queue_name}"
+            else:
+                return "crawlo:requests"  # 默认名称
+                
+        # 其他情况，保持不变
+        else:
+            return queue_name
+
     async def connect(self, max_retries=3, delay=1):
         """异步连接 Redis，支持重试"""
         async with self._lock:

crawlo/settings/default_settings.py

@@ -60,7 +60,8 @@ REQUEST_GENERATION_INTERVAL = 0.01  # 请求生成间隔（秒）
 ENABLE_CONTROLLED_REQUEST_GENERATION = False  # 是否启用受控请求生成
 
 # 调度器队列名称（遵循统一命名规范）
-SCHEDULER_QUEUE_NAME = f"crawlo:{PROJECT_NAME}:queue:requests"
+# 当使用Redis队列时，取消注释并设置此值，或在项目配置文件中设置
+# SCHEDULER_QUEUE_NAME = f"crawlo:{PROJECT_NAME}:queue:requests"
 
 # 队列类型：memory/redis/auto
 QUEUE_TYPE = 'auto'
@@ -97,13 +98,12 @@ if REDIS_PASSWORD:
 else:
     REDIS_URL = f'redis://{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB}'
 
-# 统一的Redis key命名规范配置
-# REDIS_KEY_PREFIX 已移至各组件中，使用统一的命名规范
-# crawlo:{PROJECT_NAME}:filter:fingerprint (请求去重)
-# crawlo:{PROJECT_NAME}:item:fingerprint (数据项去重)
-# crawlo:{PROJECT_NAME}:queue:requests (请求队列)
-# crawlo:{PROJECT_NAME}:queue:processing (处理中队列)
-# crawlo:{PROJECT_NAME}:queue:failed (失败队列)
+# Redis key命名规范已封装到框架内部组件中，用户无需手动配置：
+# - 请求去重: crawlo:{PROJECT_NAME}:filter:fingerprint
+# - 数据项去重: crawlo:{PROJECT_NAME}:item:fingerprint
+# - 请求队列: crawlo:{PROJECT_NAME}:queue:requests
+# - 处理中队列: crawlo:{PROJECT_NAME}:queue:processing
+# - 失败队列: crawlo:{PROJECT_NAME}:queue:failed
 
 REDIS_TTL = 0  # 指纹过期时间（0 表示永不过期）
 CLEANUP_FP = 0  # 程序结束时是否清理指纹（0=不清理）

crawlo/templates/project/settings.py.tmpl

@@ -29,6 +29,9 @@ DOWNLOADER = 'crawlo.downloader.aiohttp_downloader.AioHttpDownloader'
 # ============================== 队列配置 ==============================
 # 队列类型: 'memory', 'redis', 'auto'
 QUEUE_TYPE = 'memory'
+# 当使用Redis队列时，可自定义队列名称
+# 队列名称遵循统一命名规范: crawlo:{PROJECT_NAME}:queue:requests
+# SCHEDULER_QUEUE_NAME = f'crawlo:{PROJECT_NAME}:queue:requests'
 
 # ============================== 去重过滤器 ==============================
 FILTER_CLASS = 'crawlo.filters.memory_filter.MemoryFilter'

crawlo/templates/project/settings_distributed.py.tmpl

@@ -28,6 +28,9 @@ DOWNLOADER = 'crawlo.downloader.aiohttp_downloader.AioHttpDownloader'
 
 # ============================== 队列配置 ==============================
 QUEUE_TYPE = 'redis'
+# 当使用Redis队列时，可自定义队列名称
+# 队列名称遵循统一命名规范: crawlo:{PROJECT_NAME}:queue:requests
+# SCHEDULER_QUEUE_NAME = f'crawlo:{PROJECT_NAME}:queue:requests'
 
 # ============================== 去重过滤器 ==============================
 FILTER_CLASS = 'crawlo.filters.aioredis_filter.AioRedisFilter'

{crawlo-1.3.5.dist-info → crawlo-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crawlo
-Version: 1.3.5
+Version: 1.3.7
 Summary: Crawlo 是一款基于异步IO的高性能Python爬虫框架，支持分布式抓取。
 Home-page: https://github.com/crawl-coder/Crawlo.git
 Author: crawl-coder
@@ -630,6 +630,51 @@ Crawlo支持三种队列类型，可通过`QUEUE_TYPE`配置项设置：
 
 推荐使用`auto`模式，让框架根据环境自动选择最适合的队列类型。
 
+#### Redis Key 命名规范
+
+在分布式模式下，Crawlo框架使用Redis作为队列和去重存储。为了确保不同项目和爬虫之间的数据隔离，框架采用统一的Redis Key命名规范：
+
+##### 默认命名规则
+Redis Key遵循以下命名格式：`crawlo:{PROJECT_NAME}:{component}:{identifier}`
+
+其中：
+- `PROJECT_NAME`：项目名称，用于区分不同项目
+- `component`：组件类型，如`queue`、`filter`、`item`
+- `identifier`：具体标识符，如`requests`、`processing`、`failed`、`fingerprint`
+
+##### 具体Key格式
+1. **请求队列**：`crawlo:{PROJECT_NAME}:queue:requests`
+   - 用于存储待处理的请求任务
+
+2. **处理中队列**：`crawlo:{PROJECT_NAME}:queue:processing`
+   - 用于存储正在处理的请求任务
+
+3. **失败队列**：`crawlo:{PROJECT_NAME}:queue:failed`
+   - 用于存储处理失败的请求任务
+
+4. **请求去重**：`crawlo:{PROJECT_NAME}:filter:fingerprint`
+   - 用于存储请求URL的指纹，实现去重功能
+
+5. **数据项去重**：`crawlo:{PROJECT_NAME}:item:fingerprint`
+   - 用于存储数据项的指纹，防止重复存储
+
+##### 自定义队列名称
+用户可以通过`SCHEDULER_QUEUE_NAME`配置项自定义请求队列名称。处理中队列和失败队列会基于请求队列名称自动生成：
+- 处理中队列：将`:queue:requests`替换为`:queue:processing`
+- 失败队列：将`:queue:requests`替换为`:queue:failed`
+
+示例配置：
+```python
+# settings.py
+SCHEDULER_QUEUE_NAME = f'crawlo:{PROJECT_NAME}:queue:requests'
+```
+
+##### 命名规范优势
+1. **命名空间隔离**：通过项目名称实现不同项目间的数据隔离
+2. **组件分类清晰**：通过组件类型区分不同功能模块
+3. **易于监控和管理**：统一的命名格式便于Redis监控和管理
+4. **防止命名冲突**：避免不同项目或组件间的Key冲突
+
 <!-- 配置系统 section -->
 <h2 align="center">🎛️ 配置系统</h2>
 
@@ -1095,6 +1140,34 @@ asyncio.run(process.crawl('my_spider_name'))
 
 ---
 
+<!-- Redis键名修复说明 section -->
+<h2 align="center">🔧 Redis键名修复说明</h2>
+
+在早期版本中，Crawlo框架存在Redis队列键名生成的双重前缀问题。具体表现为：
+
+- **问题现象**：Redis队列键名出现双重"crawlo"前缀，如`crawlo:crawlo:queue:requests`而不是正确的`crawlo:{project_name}:queue:requests`
+- **影响范围**：影响分布式模式下的请求队列、处理队列和失败队列的正确识别和使用
+- **根本原因**：队列管理器中的项目名称提取逻辑未能正确处理不同格式的队列名称
+
+**修复内容**：
+
+1. **队列管理器优化**：
+   - 改进了[QueueConfig.from_settings](file:///Users/oscar/projects/Crawlo/crawlo/queue/queue_manager.py#L148-L180)方法，使其在`SCHEDULER_QUEUE_NAME`未设置时能正确使用基于项目名称的默认值
+   - 修复了队列管理器中从队列名称提取项目名称的逻辑，确保能正确处理各种前缀情况
+
+2. **Redis队列实现改进**：
+   - 在[RedisPriorityQueue](file:///Users/oscar/projects/Crawlo/crawlo/queue/redis_priority_queue.py#L39-L76)中添加了`_normalize_queue_name`方法来规范化队列名称
+   - 处理了多重"crawlo"前缀的情况，确保队列名称符合统一规范
+
+3. **配置文件调整**：
+   - 将`SCHEDULER_QUEUE_NAME`设置为注释状态，提供更大的配置灵活性
+   - 在所有模板和示例项目的配置文件中保持了一致性
+
+**验证测试**：
+通过专门的测试脚本验证了修复效果，确保在各种队列命名情况下都能正确生成和识别Redis键名。
+
+---
+
 <!-- 文档 section -->
 <h2 align="center">📚 文档</h2>
 

{crawlo-1.3.5.dist-info → crawlo-1.3.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
 crawlo/__init__.py,sha256=rCeDq1OoX6mmcBxuK60eUpEp1cIg5T8Zgic3FUQAOkA,2318
-crawlo/__version__.py,sha256=AraH1WB67qbGfdcq6TC7ARcEi7zORceoTxsCTwF_h8g,22
+crawlo/__version__.py,sha256=ejHyy8zORCf0PfUyyfPDzlV1k5vn5lI98S7TxKzblZc,22
 crawlo/cli.py,sha256=OXprmcTUbFK02ptw_Gq8Gk4-ZCU-WEMJgzU1ztgP6Bk,2327
 crawlo/config.py,sha256=dNoNyTkXLe2msQ7bZx3YTQItk1m49nIg5-g89FQDNwE,9486
 crawlo/config_validator.py,sha256=gsiLqf5swWd9ISDvoLqCdG7iSXr-ZdBPD4iT6ug1ua4,11239
 crawlo/crawler.py,sha256=wd8_jrfUBwlIw4NiaNeCwMj-CXS7F2ngeUhQ74P0wJE,25656
 crawlo/event.py,sha256=7-y6HNv_EIJSYQNzsj0mVK-Gg4ON3wdQeMdQjfFJPlw,313
 crawlo/exceptions.py,sha256=sMay0wnWLfc_FXWslqxm60qz6b66LXs3EdN_w8ygE9k,1166
-crawlo/framework.py,sha256=N0N9_GOWWYafob5iYqGT4wGAKTxSMWFbWTJuE9PRkqI,9062
+crawlo/framework.py,sha256=1RVBwj_VBzfJiMB3lq6XcfFHCjRBHyT4D_T2X4fU_6g,9166
 crawlo/mode_manager.py,sha256=JP8_jkH2p9LMg1-g1e05PhSggSvt4jO_oO2h51pLVYQ,7399
 crawlo/project.py,sha256=DooXmO0nmcHPVRsnDBTE0dOrX-KOqnJe6A0s_-qOxRI,12147
 crawlo/stats_collector.py,sha256=copzmfWTArYZCkMeZJsJfJcdC36s7_LM88hxAYttoeE,2306
@@ -90,10 +90,10 @@ crawlo/pipelines/pipeline_manager.py,sha256=rtKZEgDc9oMDYaTrSSQYCc7rVJ-a65TQw4p3
 crawlo/pipelines/redis_dedup_pipeline.py,sha256=POYRiWAOp1pqDW9iTPJ8h3VcpLALeLrpw74MvJJqPiM,6342
 crawlo/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crawlo/queue/pqueue.py,sha256=j2ISmyays5t1tuI36xM6EcELwSpq2xIjAScSBWSRZms,1220
-crawlo/queue/queue_manager.py,sha256=t-49ygGHAvOZ08v5zj4F06Iq2JUCSK5vZldRg-4sVtI,19669
-crawlo/queue/redis_priority_queue.py,sha256=5mEgMjqg7XrQrWOhWpwGwycmA-qcwfHtr8w7cKHs4-E,13657
+crawlo/queue/queue_manager.py,sha256=JfkjtOD04e_OZZvEEvp3O_W3lfGXhHslZHrCgw90amY,20693
+crawlo/queue/redis_priority_queue.py,sha256=Evmo514OFL0a7Xu2SdCiz6klFUGH1gmjlxCc01vX1tQ,15400
 crawlo/settings/__init__.py,sha256=xsukVKn_h2Hopm1Nj-bXkhbfyS62QTTvJi7fhZUwR9M,123
-crawlo/settings/default_settings.py,sha256=vmacY04PZqumteQn7URMo0r3JWwJCctXaJcoxlW5-M0,13144
+crawlo/settings/default_settings.py,sha256=LReJ11Wm8wh1z2GHgGRBYH6Tpq6_CkRd8QZ4dKRCqI0,13220
 crawlo/settings/setting_manager.py,sha256=AWPvvhOGo04Yv_q3jqEMyzhEpbxOX_Wr8tSHmI2sUnA,8109
 crawlo/spider/__init__.py,sha256=oi9LEYq9xaCSjktAIRUgjpGQQI7rTtN61ESdHeWb1x4,21224
 crawlo/templates/crawlo.cfg.tmpl,sha256=9BAmwEibS5Tvy6HIcGXPb0BGeuesmibebmTW0iAEkmo,230
@@ -103,8 +103,8 @@ crawlo/templates/project/__init__.py.tmpl,sha256=f3ETIXw_O6K-lkL6lXM5znMPJW1FZYG
 crawlo/templates/project/items.py.tmpl,sha256=mt1Mm--H2Ouos3r7JPkYh0r33rgYJf1YOMz0OZy8TYs,297
 crawlo/templates/project/middlewares.py.tmpl,sha256=T67p8j0laL4NJJ_3xzPM9yivgZRjTEMiEtEWLPwbkmw,4160
 crawlo/templates/project/pipelines.py.tmpl,sha256=GBHYU0Jx8sKDCdGJp44FMSH7u2slxoFg6a-R9Uwg_-I,2608
-crawlo/templates/project/settings.py.tmpl,sha256=qat0jBxnWXZDhCdmHh86JC4eDodRuNW9mKQ6mIBaiCY,6685
-crawlo/templates/project/settings_distributed.py.tmpl,sha256=q1v2HBS6NF1Ebwb1ia9z5DV9Zv3CREZPDJSDuCryv58,6783
+crawlo/templates/project/settings.py.tmpl,sha256=ETZnuGQvWhLdiXeu1FTH8vlHZ3d66GoC8qEzep9ZMrI,6880
+crawlo/templates/project/settings_distributed.py.tmpl,sha256=BxNjURczwiBoowdMYCM631IXlQIJ15jd5wug7b_5RGw,6978
 crawlo/templates/project/settings_gentle.py.tmpl,sha256=ZT6d-1Ao0h90vT82W9BSZuF8tsdyC4RU3446u1mh104,6631
 crawlo/templates/project/settings_high_performance.py.tmpl,sha256=Z_oWA4_a2yKOFAPG8lsLue2L6RzuKp8flq_NscAQvqA,6720
 crawlo/templates/project/settings_minimal.py.tmpl,sha256=6_7R0T9iIBOInTP9HX-icEvPOhd8-B3lmiZEz30kzV0,2485
@@ -191,6 +191,7 @@ tests/simple_crawlo_test.py,sha256=8x8DNL7O_1DNtOQ_K7YsOFIZoWeGmpeEP9mKWHlkbHg,4
 tests/simple_log_test.py,sha256=4daRH0bqTViz-BmyPcAZY9xKGks7G5kb39MH5W7v2XI,1700
 tests/simple_log_test2.py,sha256=Z2xcCiT_-sCd1Sd-SK7hINcn6WcH_-7Bq0TWAei-XIg,3807
 tests/simple_optimization_test.py,sha256=CyhyzW9lhPlTDAwrJu7gTWwcEQuCBL_Bnm9mkS_-iFo,3550
+tests/simple_queue_type_test.py,sha256=OClhm3GvwWxONuUQqFD1KygGwUVnuYuxUvUY5OgyeKs,1152
 tests/simple_spider_test.py,sha256=X5oFRV02mkOXUd5lpzOBF7gX8K62j4ZwAUXoBEZ0KKE,1119
 tests/simple_test.py,sha256=kzMspCmfJxdnAIXXJv9tmDW1gpodkD9pznW5vA_gL84,1211
 tests/spider_log_timing_test.py,sha256=ngZQ_v3o9oHYcs_BtZgxH1N-N2tZUDPu-cnTnsHEpP8,5396
@@ -206,11 +207,11 @@ tests/test_config_consistency.py,sha256=DJaAQxGL7RXHs-DWF_B4yhHFGSGHWHUoDmLFiMi4
 tests/test_config_merge.py,sha256=d8i8sU1XKS3egNKEYPZ2a6CBnJRx2M3p6q04wYufAcw,5454
 tests/test_config_validator.py,sha256=5ivB71KstHGNi2BPzcclf9hBukXEgt_B8N4l1HRjBFc,6020
 tests/test_controlled_spider_mixin.py,sha256=7t6VGWr6Hxw0xtIFyToLH8_deSagUtsdqSJpibXHMY8,2785
-tests/test_crawlo_proxy_integration.py,sha256=_L62_soaHRYy_0fShjiZSmv-RtGICw7_kzhTNRoyFfc,2620
+tests/test_crawlo_proxy_integration.py,sha256=SvdBuZjS6N2vuvFkTnc59U5n3dHV3E4dmFayxtmjCm4,2625
 tests/test_date_tools.py,sha256=CQdAmIS6bpAdwQH9ETDH__06l2gGL7EHUQuh7mdTF-A,3930
 tests/test_default_header_middleware.py,sha256=7kpONSsGMsmWgTX2pCpseme54_-82Baak0xVz6gclJk,5845
 tests/test_distributed.py,sha256=RQHUpDfRNG2x_1Cdr9DLk25IBcgapm_u0xSBMObE0Xc,1725
-tests/test_double_crawlo_fix.py,sha256=ZNkRDgWW2WN-QRNZhvIgTHonY-T_U_R_MOIBLuyJd_I,7770
+tests/test_double_crawlo_fix.py,sha256=E5NxWHnQkwRTIrJGoag8G29fZqVMnsN6eCPuv17gGq0,7652
 tests/test_double_crawlo_fix_simple.py,sha256=MlWUqo51kOQ7Gu6Neoler8FVyRs0jpmQWoORHMBENz0,4644
 tests/test_download_delay_middleware.py,sha256=Va79gsH_8BVrVVLA8gSwFEbrRJ7qwJMCC1cDJN6il_0,8886
 tests/test_downloader_proxy_compatibility.py,sha256=3Jn7RJd1R2ywuitHp2Jju1yYNg57R4QmKwjuHGojDUE,8635
@@ -251,7 +252,9 @@ tests/test_proxy_stats.py,sha256=Til_yksrRz2yBVw-yJi5-36LhNW3vTwpXTm4BdR9PUM,507
 tests/test_proxy_strategies.py,sha256=ZkziozkvZd3KWOQnpHQ8Upd3WpyoX7gN0qFGluNm348,1809
 tests/test_queue_empty_check.py,sha256=FsFoThG8qXzhXtG9Gu4hHuz--iVZHSbFbGJh4vgq_ec,1141
 tests/test_queue_manager_double_crawlo.py,sha256=YzM6PnoyRSST-f2NVyI97bpPcoYWL06HUwf08Fyx3Qg,6784
-tests/test_queue_manager_redis_key.py,sha256=nCCMnpKPNP5fyd4zb4LG2kmJAUcLoa8ODhBGcz4GcCU,6231
+tests/test_queue_manager_redis_key.py,sha256=qWkrXXlOg6IAi7OLPhBb524KbQHmHusAeYYi1W3yhqY,6938
+tests/test_queue_naming.py,sha256=kDqj-n_k5KrFF5up1Ur6WmGS4Jqmk-QgKrkAtAyE4tk,4632
+tests/test_queue_type.py,sha256=pD9v8Zcf8y6zAEKzko4Qo6FiwrEavXKMTS8Pni2r_8U,3198
 tests/test_random_user_agent.py,sha256=LuyR8WaKfqOap9WBQl4WEBcZDmKxhW80T-_wXbuo2Qw,2230
 tests/test_real_scenario_proxy.py,sha256=LGtxEvCiTgn6aTPGd7ZuqaCjApsjosD2DunJrd8-jFE,8259
 tests/test_redis_config.py,sha256=DBrqURBQt517Rt1h1l2iIKrKDfbkJzQSRUEYYbapcy4,875
@@ -259,6 +262,7 @@ tests/test_redis_connection_pool.py,sha256=WIUQlI6K3IINan14vknI4oFf9a8wpHCWi87KS
 tests/test_redis_key_naming.py,sha256=7_X_PSzFQn5m0n_7qLlCjFvY4ZKScC36cqWFu1PAFRw,6730
 tests/test_redis_key_validator.py,sha256=VFuawmaA0G7VSHueCvZEQNKY-L2IdDGlEcyuJ9nZu7Q,4295
 tests/test_redis_queue.py,sha256=2OZJHn5fN9b6XEgEs4Ht1AL6TOJ_H-IR9JxPzzvqMpg,6534
+tests/test_redis_queue_name_fix.py,sha256=FSbhPMP8k_JP75TeOIPRbgQ7VQ2e5AVYRWjiPgIhelE,5595
 tests/test_request_ignore_middleware.py,sha256=8_2E6JU27eOWI3iHeh3YscLnp3SIHaubWdA477Ki6PE,6047
 tests/test_request_params.py,sha256=9vNksaOrFbuSb0UffruPxUHhJXZxVYyjQw9J69FSzH8,4176
 tests/test_request_serialization.py,sha256=TPBIzjaifcAjFWCFSFZ5ewRn814jSGPL28MGTwvrr_w,2262
@@ -281,8 +285,8 @@ tests/verify_distributed.py,sha256=krnYYA5Qx9xXDMWc9YF5DxPSplGvawDg2n0l-3CAqoM,3
 tests/verify_log_fix.py,sha256=TD7M1R22NxLqQPufvgE-H33u9tUjyz-rSR2ayIXozRU,4225
 tests/scrapy_comparison/ofweek_scrapy.py,sha256=2Hvpi6DRTubUxBy6RyJApQxMQONPLc1zWjKTQO_i5U4,5652
 tests/scrapy_comparison/scrapy_test.py,sha256=5sw7jOHhaTmQ8bsUd1TiolAUTRQYQOe-f49HPfysqbI,5466
-crawlo-1.3.5.dist-info/METADATA,sha256=RDqsfzstoxtnrY_AR26XXQ3MbZA-W7sdCx4_CPReUGo,29742
-crawlo-1.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-crawlo-1.3.5.dist-info/entry_points.txt,sha256=5HoVoTSPxI8SCa5B7pQYxLSrkOdiunyO9tqNsLMv52g,43
-crawlo-1.3.5.dist-info/top_level.txt,sha256=keG_67pbZ_wZL2dmDRA9RMaNHTaV_x_oxZ9DKNgwvR0,22
-crawlo-1.3.5.dist-info/RECORD,,
+crawlo-1.3.7.dist-info/METADATA,sha256=rHuHJj9-pUt4TJRUgQcNV48DM6LRk0Ag8Ek5pZZeqLk,33235
+crawlo-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+crawlo-1.3.7.dist-info/entry_points.txt,sha256=5HoVoTSPxI8SCa5B7pQYxLSrkOdiunyO9tqNsLMv52g,43
+crawlo-1.3.7.dist-info/top_level.txt,sha256=keG_67pbZ_wZL2dmDRA9RMaNHTaV_x_oxZ9DKNgwvR0,22
+crawlo-1.3.7.dist-info/RECORD,,

tests/simple_queue_type_test.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+简单测试 QUEUE_TYPE 配置获取
+验证我们的日志格式修改是否正常工作
+"""
+
+import sys
+import os
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.config import CrawloConfig
+from crawlo.framework import CrawloFramework
+
+
+def test_log_format():
+    """测试日志格式修改是否正常工作"""
+    print("=== 测试日志格式修改 ===")
+    
+    # 创建单机模式配置
+    config = CrawloConfig.standalone(concurrency=4)
+    
+    # 创建框架实例，这会触发日志输出
+    framework = CrawloFramework(config.to_dict())
+    
+    # 获取配置信息
+    run_mode = framework.settings.get('RUN_MODE', 'not found')
+    queue_type = framework.settings.get('QUEUE_TYPE', 'not found')
+    
+    print(f"从配置中获取到的信息:")
+    print(f"  RunMode: {run_mode}")
+    print(f"  QueueType: {queue_type}")
+    
+    print("\n✅ 日志格式修改测试完成")
+
+
+if __name__ == "__main__":
+    print("开始简单测试 QUEUE_TYPE 配置获取...")
+    test_log_format()
+    print("\n测试结束！")

tests/test_crawlo_proxy_integration.py

@@ -45,7 +45,7 @@ class ProxyTestSpider(Spider):
         
         item = TestItem(
             url=response.url,
-            status=response.status,
+            status=response.status_code,
             proxy=str(response.meta.get('proxy', 'No proxy'))
         )
         

tests/test_double_crawlo_fix.py

@@ -34,18 +34,18 @@ async def test_redis_queue_naming():
         {
             "name": "双重 crawlo 前缀",
             "queue_name": "crawlo:crawlo:queue:requests",
-            "expected_module": "crawlo",
-            "expected_queue": "crawlo:crawlo:queue:requests",
-            "expected_processing": "crawlo:crawlo:queue:processing",
-            "expected_failed": "crawlo:crawlo:queue:failed"
+            "expected_module": "test_project",
+            "expected_queue": "crawlo:queue:requests",  # 修复后的期望值
+            "expected_processing": "crawlo:queue:processing",
+            "expected_failed": "crawlo:queue:failed"
         },
         {
             "name": "三重 crawlo 前缀",
             "queue_name": "crawlo:crawlo:crawlo:queue:requests",
-            "expected_module": "crawlo",
-            "expected_queue": "crawlo:crawlo:queue:requests",
-            "expected_processing": "crawlo:crawlo:queue:processing",
-            "expected_failed": "crawlo:crawlo:queue:failed"
+            "expected_module": "test_project",
+            "expected_queue": "crawlo:queue:requests",  # 修复后的期望值
+            "expected_processing": "crawlo:queue:processing",
+            "expected_failed": "crawlo:queue:failed"
         },
         {
             "name": "无 crawlo 前缀",
@@ -138,11 +138,8 @@ async def test_queue_manager_naming():
                 if len(parts) >= 2:
                     # 处理可能的双重 crawlo 前缀
                     if parts[0] == "crawlo" and parts[1] == "crawlo":
-                        # 双重 crawlo 前缀，取第三个部分作为项目名称
-                        if len(parts) >= 3:
-                            project_name = parts[2]
-                        else:
-                            project_name = "default"
+                        # 双重 crawlo 前缀，取"crawlo"作为项目名称
+                        project_name = "crawlo"
                     elif parts[0] == "crawlo":
                         # 正常的 crawlo 前缀，取第二个部分作为项目名称
                         project_name = parts[1]

tests/test_queue_manager_redis_key.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
-QueueManager Redis Key 测试脚本
-用于验证QueueManager在创建RedisPriorityQueue时是否正确传递module_name参数
+QueueManager Redis Key测试脚本
+用于验证QueueManager创建Redis队列时是否正确传递module_name参数
 """
 import asyncio
 import sys
@@ -12,40 +12,32 @@ import traceback
 # 添加项目根目录到路径
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 
+# 导入相关模块
 from crawlo.queue.queue_manager import QueueManager, QueueConfig, QueueType
 
 
 class MockSettings:
     """模拟设置类"""
-    def __init__(self, project_name="test_project"):
-        self.project_name = project_name
-        self.REDIS_URL = "redis://127.0.0.1:6379/15"  # 使用测试数据库
+    def __init__(self):
+        self.REDIS_HOST = '127.0.0.1'
+        self.REDIS_PORT = 6379
+        self.REDIS_PASSWORD = ''
+        self.REDIS_DB = 0
+        self.REDIS_URL = 'redis://127.0.0.1:6379/0'
         self.REDIS_TTL = 0
-        self.CLEANUP_FP = 0
-        self.FILTER_DEBUG = True
-        self.LOG_LEVEL = "INFO"
-        self.DECODE_RESPONSES = True
+        self.SCHEDULER_MAX_QUEUE_SIZE = 1000
+        self.QUEUE_MAX_RETRIES = 3
+        self.QUEUE_TIMEOUT = 300
     
     def get(self, key, default=None):
-        if key == 'PROJECT_NAME':
-            return self.project_name
+        if key == 'REDIS_HOST':
+            return self.REDIS_HOST
+        elif key == 'REDIS_PASSWORD':
+            return self.REDIS_PASSWORD
         elif key == 'REDIS_URL':
             return self.REDIS_URL
-        elif key == 'FILTER_DEBUG':
-            return self.FILTER_DEBUG
-        elif key == 'LOG_LEVEL':
-            return self.LOG_LEVEL
-        elif key == 'DECODE_RESPONSES':
-            return self.DECODE_RESPONSES
-        return default
-    
-    def get_bool(self, key, default=False):
-        if key == 'FILTER_DEBUG':
-            return self.FILTER_DEBUG
-        elif key == 'DECODE_RESPONSES':
-            return self.DECODE_RESPONSES
-        elif key == 'CLEANUP_FP':
-            return self.CLEANUP_FP
+        elif key == 'REDIS_TTL':
+            return self.REDIS_TTL
         return default
     
     def get_int(self, key, default=0):
@@ -74,26 +66,41 @@ async def test_queue_manager_redis_key():
             {
                 "queue_name": "crawlo:books_distributed:queue:requests",
                 "expected_module_name": "books_distributed",
+                "expected_queue_name": "crawlo:books_distributed:queue:requests",
+                "expected_processing_queue": "crawlo:books_distributed:queue:processing",
+                "expected_failed_queue": "crawlo:books_distributed:queue:failed",
                 "description": "标准项目名称"
             },
             {
                 "queue_name": "crawlo:api_data_collection:queue:requests",
                 "expected_module_name": "api_data_collection",
+                "expected_queue_name": "crawlo:api_data_collection:queue:requests",
+                "expected_processing_queue": "crawlo:api_data_collection:queue:processing",
+                "expected_failed_queue": "crawlo:api_data_collection:queue:failed",
                 "description": "API数据采集项目"
             },
             {
                 "queue_name": "crawlo:test_project:queue:requests",
                 "expected_module_name": "test_project",
+                "expected_queue_name": "crawlo:test_project:queue:requests",
+                "expected_processing_queue": "crawlo:test_project:queue:processing",
+                "expected_failed_queue": "crawlo:test_project:queue:failed",
                 "description": "测试项目"
             },
             {
                 "queue_name": "simple_queue_name",
                 "expected_module_name": "simple_queue_name",
+                "expected_queue_name": "crawlo:simple_queue_name",  # RedisPriorityQueue会规范化名称
+                "expected_processing_queue": "crawlo:simple_queue_name:processing",
+                "expected_failed_queue": "crawlo:simple_queue_name:failed",
                 "description": "简单队列名称"
             },
             {
                 "queue_name": "",
                 "expected_module_name": "default",
+                "expected_queue_name": "crawlo:",  # 空字符串会规范化为"crawlo:"
+                "expected_processing_queue": "crawlo::processing",
+                "expected_failed_queue": "crawlo::failed",
                 "description": "空队列名称"
             }
         ]
@@ -123,16 +130,12 @@ async def test_queue_manager_redis_key():
                 f"module_name不匹配: {queue.module_name} != {test_case['expected_module_name']}"
             
             # 验证队列名称是否符合规范
-            expected_queue_name = f"crawlo:{queue.module_name}:queue:requests"
-            expected_processing_queue = f"crawlo:{queue.module_name}:queue:processing"
-            expected_failed_queue = f"crawlo:{queue.module_name}:queue:failed"
-            
-            assert queue.queue_name == expected_queue_name, \
-                f"队列名称不匹配: {queue.queue_name} != {expected_queue_name}"
-            assert queue.processing_queue == expected_processing_queue, \
-                f"处理中队列名称不匹配: {queue.processing_queue} != {expected_processing_queue}"
-            assert queue.failed_queue == expected_failed_queue, \
-                f"失败队列名称不匹配: {queue.failed_queue} != {expected_failed_queue}"
+            assert queue.queue_name == test_case["expected_queue_name"], \
+                f"队列名称不匹配: {queue.queue_name} != {test_case['expected_queue_name']}"
+            assert queue.processing_queue == test_case["expected_processing_queue"], \
+                f"处理中队列名称不匹配: {queue.processing_queue} != {test_case['expected_processing_queue']}"
+            assert queue.failed_queue == test_case["expected_failed_queue"], \
+                f"失败队列名称不匹配: {queue.failed_queue} != {test_case['expected_failed_queue']}"
             
             print(f"      module_name: {queue.module_name}")
             print(f"      队列名称: {queue.queue_name}")

tests/test_queue_naming.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+队列命名测试脚本
+用于验证Redis队列命名修复
+"""
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
+
+from crawlo.queue.redis_priority_queue import RedisPriorityQueue
+
+
+class MockRequest:
+    def __init__(self, url):
+        self.url = url
+        self.priority = 0
+        self.meta = {}
+
+
+def test_queue_naming():
+    """测试队列命名"""
+    print("开始测试Redis队列命名...")
+    print("=" * 50)
+    
+    # 测试用例
+    test_cases = [
+        {
+            "name": "正常命名",
+            "queue_name": "crawlo:test_project:queue:requests",
+            "expected_queue": "crawlo:test_project:queue:requests",
+            "expected_processing": "crawlo:test_project:queue:processing",
+            "expected_failed": "crawlo:test_project:queue:failed"
+        },
+        {
+            "name": "双重 crawlo 前缀",
+            "queue_name": "crawlo:crawlo:queue:requests",
+            "expected_queue": "crawlo:queue:requests",
+            "expected_processing": "crawlo:queue:processing",
+            "expected_failed": "crawlo:queue:failed"
+        }
+    ]
+    
+    all_passed = True
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"测试 {i}: {test_case['name']}")
+        print(f"  输入队列名称: {test_case['queue_name']}")
+        
+        # 创建RedisPriorityQueue实例
+        queue = RedisPriorityQueue(
+            redis_url="redis://127.0.0.1:6379/0",
+            queue_name=test_case['queue_name'],
+            module_name="test_project"
+        )
+        
+        print(f"  实际队列名称: {queue.queue_name}")
+        print(f"  实际处理队列: {queue.processing_queue}")
+        print(f"  实际失败队列: {queue.failed_queue}")
+        
+        print(f"  期望队列名称: {test_case['expected_queue']}")
+        print(f"  期望处理队列: {test_case['expected_processing']}")
+        print(f"  期望失败队列: {test_case['expected_failed']}")
+        
+        # 验证结果
+        queue_name_ok = queue.queue_name == test_case['expected_queue']
+        processing_queue_ok = queue.processing_queue == test_case['expected_processing']
+        failed_queue_ok = queue.failed_queue == test_case['expected_failed']
+        
+        if queue_name_ok and processing_queue_ok and failed_queue_ok:
+            print("  ✓ 测试通过")
+        else:
+            print("  ✗ 测试失败")
+            all_passed = False
+            
+        print()
+    
+    return all_passed
+
+
+async def test_queue_operations():
+    """测试队列操作"""
+    print("开始测试Redis队列操作...")
+    print("=" * 50)
+    
+    # 创建一个RedisPriorityQueue实例
+    queue = RedisPriorityQueue(
+        redis_url='redis://127.0.0.1:6379/0',
+        queue_name='crawlo:test_project:queue:requests',
+        module_name='test_project'
+    )
+    
+    # 连接Redis
+    await queue.connect()
+    
+    print('队列名称:', queue.queue_name)
+    print('处理队列:', queue.processing_queue)
+    print('失败队列:', queue.failed_queue)
+    
+    # 清理之前的测试数据
+    await queue._redis.delete(queue.queue_name)
+    await queue._redis.delete(f'{queue.queue_name}:data')
+    await queue._redis.delete(queue.processing_queue)
+    await queue._redis.delete(f'{queue.processing_queue}:data')
+    await queue._redis.delete(queue.failed_queue)
+    
+    # 添加一个测试任务
+    request = MockRequest('https://example.com')
+    
+    # 测试放入队列
+    result = await queue.put(request, priority=1)
+    print('放入队列结果:', result)
+    
+    # 检查队列大小
+    size = await queue.qsize()
+    print('队列大小:', size)
+    
+    # 测试获取任务
+    retrieved = await queue.get(timeout=1.0)
+    print('获取请求:', retrieved.url if retrieved else None)
+    
+    if retrieved:
+        # 测试确认任务完成
+        await queue.ack(retrieved)
+        print('任务确认完成')
+    
+    # 关闭连接
+    await queue.close()
+    print("队列操作测试完成")
+
+
+async def main():
+    """主测试函数"""
+    print("开始Redis队列命名和操作测试...")
+    print("=" * 50)
+    
+    # 测试队列命名
+    naming_test_passed = test_queue_naming()
+    
+    # 测试队列操作
+    await test_queue_operations()
+    
+    print("=" * 50)
+    if naming_test_passed:
+        print("所有测试通过！")
+    else:
+        print("部分测试失败！")
+    print("测试完成！")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_queue_type.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+测试 QUEUE_TYPE 配置获取
+"""
+
+import sys
+import os
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.framework import CrawloFramework
+from crawlo.config import CrawloConfig
+
+
+def test_queue_type_standalone():
+    """测试单机模式下的 QUEUE_TYPE"""
+    print("=== 测试单机模式下的 QUEUE_TYPE ===")
+    
+    # 创建单机模式配置
+    config = CrawloConfig.standalone(concurrency=4)
+    
+    # 创建框架实例
+    framework = CrawloFramework(config.to_dict())
+    
+    # 获取 QUEUE_TYPE
+    queue_type = framework.settings.get('QUEUE_TYPE', 'not found')
+    run_mode = framework.settings.get('RUN_MODE', 'not found')
+    
+    print(f"RunMode: {run_mode}")
+    print(f"QueueType: {queue_type}")
+    
+    # 验证是否正确
+    assert queue_type == 'memory', f"期望 'memory'，实际得到 '{queue_type}'"
+    assert run_mode == 'standalone', f"期望 'standalone'，实际得到 '{run_mode}'"
+    
+    print("✅ 单机模式测试通过")
+
+
+def test_queue_type_distributed():
+    """测试分布式模式下的 QUEUE_TYPE"""
+    print("\n=== 测试分布式模式下的 QUEUE_TYPE ===")
+    
+    # 创建分布式模式配置
+    config = CrawloConfig.distributed(
+        redis_host='127.0.0.1',
+        redis_port=6379,
+        project_name='test_project',
+        concurrency=4
+    )
+    
+    # 创建框架实例
+    framework = CrawloFramework(config.to_dict())
+    
+    # 获取 QUEUE_TYPE
+    queue_type = framework.settings.get('QUEUE_TYPE', 'not found')
+    run_mode = framework.settings.get('RUN_MODE', 'not found')
+    
+    print(f"RunMode: {run_mode}")
+    print(f"QueueType: {queue_type}")
+    
+    # 验证是否正确
+    assert queue_type == 'redis', f"期望 'redis'，实际得到 '{queue_type}'"
+    assert run_mode == 'distributed', f"期望 'distributed'，实际得到 '{run_mode}'"
+    
+    print("✅ 分布式模式测试通过")
+
+
+def test_queue_type_auto():
+    """测试自动模式下的 QUEUE_TYPE"""
+    print("\n=== 测试自动模式下的 QUEUE_TYPE ===")
+    
+    # 创建自动模式配置
+    config = CrawloConfig.auto(concurrency=4)
+    
+    # 创建框架实例
+    framework = CrawloFramework(config.to_dict())
+    
+    # 获取 QUEUE_TYPE
+    queue_type = framework.settings.get('QUEUE_TYPE', 'not found')
+    run_mode = framework.settings.get('RUN_MODE', 'not found')
+    
+    print(f"RunMode: {run_mode}")
+    print(f"QueueType: {queue_type}")
+    
+    # 验证是否正确
+    assert queue_type == 'auto', f"期望 'auto'，实际得到 '{queue_type}'"
+    assert run_mode == 'auto', f"期望 'auto'，实际得到 '{run_mode}'"
+    
+    print("✅ 自动模式测试通过")
+
+
+if __name__ == "__main__":
+    print("开始测试 QUEUE_TYPE 配置获取...")
+    
+    try:
+        test_queue_type_standalone()
+        test_queue_type_distributed()
+        test_queue_type_auto()
+        
+        print("\n🎉 所有测试通过！可以成功获取到 QUEUE_TYPE 配置。")
+        
+    except Exception as e:
+        print(f"\n❌ 测试失败: {e}")
+        import traceback
+        traceback.print_exc()

tests/test_redis_queue_name_fix.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Redis队列名称修复测试脚本
+用于验证RedisPriorityQueue中队列名称处理的修复
+"""
+import sys
+import os
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+# 导入相关模块
+from crawlo.queue.redis_priority_queue import RedisPriorityQueue
+
+
+def test_normalize_queue_name():
+    """测试队列名称规范化函数"""
+    print("开始测试RedisPriorityQueue队列名称规范化...")
+    print("=" * 50)
+    
+    # 创建一个RedisPriorityQueue实例用于测试
+    queue = RedisPriorityQueue(redis_url="redis://127.0.0.1:6379/15")
+    
+    test_cases = [
+        {
+            "name": "已经规范化的名称",
+            "input": "crawlo:test_project:queue:requests",
+            "expected": "crawlo:test_project:queue:requests"
+        },
+        {
+            "name": "双重 crawlo 前缀",
+            "input": "crawlo:crawlo:queue:requests",
+            "expected": "crawlo:queue:requests"
+        },
+        {
+            "name": "三重 crawlo 前缀",
+            "input": "crawlo:crawlo:crawlo:queue:requests",
+            "expected": "crawlo:queue:requests"
+        },
+        {
+            "name": "无 crawlo 前缀",
+            "input": "test_project:queue:requests",
+            "expected": "crawlo:test_project:queue:requests"
+        },
+        {
+            "name": "空队列名称",
+            "input": "",
+            "expected": "crawlo:requests"
+        }
+    ]
+    
+    all_passed = True
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"测试 {i}: {test_case['name']}")
+        print(f"  输入: {test_case['input']}")
+        
+        # 测试规范化函数
+        result = queue._normalize_queue_name(test_case['input'])
+        print(f"  输出: {result}")
+        print(f"  期望: {test_case['expected']}")
+        
+        # 验证结果
+        if result == test_case['expected']:
+            print("  ✓ 测试通过")
+        else:
+            print("  ✗ 测试失败")
+            all_passed = False
+            
+        print()
+    
+    print("=" * 50)
+    if all_passed:
+        print("所有测试通过！队列名称规范化修复成功")
+        return True
+    else:
+        print("部分测试失败，请检查实现")
+        return False
+
+
+def test_queue_initialization():
+    """测试队列初始化时的名称处理"""
+    print("开始测试RedisPriorityQueue初始化时的名称处理...")
+    print("=" * 50)
+    
+    test_cases = [
+        {
+            "name": "正常命名",
+            "queue_name": "crawlo:test_project:queue:requests",
+            "expected_queue": "crawlo:test_project:queue:requests",
+            "expected_processing": "crawlo:test_project:queue:processing",
+            "expected_failed": "crawlo:test_project:queue:failed"
+        },
+        {
+            "name": "双重 crawlo 前缀",
+            "queue_name": "crawlo:crawlo:queue:requests",
+            "expected_queue": "crawlo:queue:requests",
+            "expected_processing": "crawlo:queue:processing",
+            "expected_failed": "crawlo:queue:failed"
+        }
+    ]
+    
+    all_passed = True
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"测试 {i}: {test_case['name']}")
+        print(f"  输入队列名称: {test_case['queue_name']}")
+        
+        try:
+            # 创建RedisPriorityQueue实例
+            queue = RedisPriorityQueue(
+                redis_url="redis://127.0.0.1:6379/15",
+                queue_name=test_case['queue_name'],
+                module_name="test_project"
+            )
+            
+            print(f"  实际队列名称: {queue.queue_name}")
+            print(f"  实际处理队列: {queue.processing_queue}")
+            print(f"  实际失败队列: {queue.failed_queue}")
+            
+            print(f"  期望队列名称: {test_case['expected_queue']}")
+            print(f"  期望处理队列: {test_case['expected_processing']}")
+            print(f"  期望失败队列: {test_case['expected_failed']}")
+            
+            # 验证结果
+            queue_name_ok = queue.queue_name == test_case['expected_queue']
+            processing_queue_ok = queue.processing_queue == test_case['expected_processing']
+            failed_queue_ok = queue.failed_queue == test_case['expected_failed']
+            
+            if queue_name_ok and processing_queue_ok and failed_queue_ok:
+                print("  ✓ 测试通过")
+            else:
+                print("  ✗ 测试失败")
+                all_passed = False
+                
+        except Exception as e:
+            print(f"  ✗ 测试异常: {e}")
+            all_passed = False
+            
+        print()
+    
+    print("=" * 50)
+    if all_passed:
+        print("队列初始化测试通过！")
+        return True
+    else:
+        print("队列初始化测试失败！")
+        return False
+
+
+def main():
+    """主测试函数"""
+    print("开始Redis队列名称修复测试...")
+    print("=" * 50)
+    
+    # 测试队列名称规范化函数
+    normalize_test_passed = test_normalize_queue_name()
+    print()
+    
+    # 测试队列初始化
+    init_test_passed = test_queue_initialization()
+    print()
+    
+    print("=" * 50)
+    if normalize_test_passed and init_test_passed:
+        print("所有测试通过！Redis队列名称修复完成")
+        return 0
+    else:
+        print("部分测试失败，请检查实现")
+        return 1
+
+
+if __name__ == "__main__":
+    exit_code = main()
+    sys.exit(exit_code)