cobweb-launcher 1.1.23__tar.gz → 1.2.1__tar.gz

cobweb-launcher-1.2.1/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.1
+Name: cobweb-launcher
+Version: 1.2.1
+Summary: spider_hole
+Home-page: https://github.com/Juannie-PP/cobweb
+Author: Juannie-PP
+Author-email: 2604868278@qq.com
+License: MIT
+Keywords: cobweb-launcher, cobweb
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# cobweb 
+cobweb是一个基于python的分布式爬虫调度框架，目前支持分布式爬虫，单机爬虫，支持自定义数据库，支持自定义数据存储，支持自定义数据处理等操作。  
+
+cobweb主要由3个模块和一个配置文件组成：Launcher启动器、Crawler采集器、Pipeline存储和setting配置文件。
+1. Launcher启动器：用于启动爬虫任务，控制爬虫任务的执行流程，以及数据存储和数据处理。
+框架提供两种启动器模式：LauncherAir、LauncherPro，分别对应单机爬虫模式和分布式调度模式。
+2. Crawler采集器：用于控制采集流程、数据下载和数据处理。
+框架提供了基础的采集器，用于控制采集流程、数据下载和数据处理，用户也可在创建任务时自定义请求、下载和解析方法，具体看使用方法介绍。
+3. Pipeline存储：用于存储采集到的数据，支持自定义数据存储和数据处理。框架提供了Console和Loghub两种存储方式，用户也可继承Pipeline抽象类自定义存储方式。
+4. setting配置文件：用于配置采集器、存储器、队列长度、采集线程数等参数，框架提供了默认配置，用户也可自定义配置。
+## 安装
+```
+pip3 install --upgrade cobweb-launcher
+```
+## 使用方法介绍
+### 1. 任务创建
+- LauncherAir任务创建
+```python
+from cobweb import LauncherAir
+
+# 创建启动器
+app = LauncherAir(task="test", project="test")
+
+# 设置采集种子
+app.SEEDS = [{
+    "url": "https://www.baidu.com"
+}]
+...
+# 启动任务
+app.start()
+```
+- LauncherPro任务创建  
+LauncherPro依赖redis实现分布式调度，使用LauncherPro启动器需要完成环境变量的配置或自定义setting文件中的redis配置，如何配置查看`2. 自定义配置文件参数`
+```python
+from cobweb import LauncherPro
+
+# 创建启动器
+app = LauncherPro(
+    task="test",
+    project="test"
+)
+...
+# 启动任务
+app.start()
+```
+### 2. 自定义配置文件参数
+- 通过自定义setting文件，配置文件导入字符串方式  
+> 默认配置文件：import cobweb.setting  
+> 不推荐！！！目前有bug，随缘使用...
+例如：同级目录下自定义创建了setting.py文件。
+```python
+from cobweb import LauncherAir
+
+app = LauncherAir(
+    task="test", 
+    project="test",
+    setting="import setting"
+)
+
+...
+
+app.start()
+```
+- 自定义修改setting中对象值
+```python
+from cobweb import LauncherPro
+
+# 创建启动器
+app = LauncherPro(
+    task="test",
+    project="test",
+    REDIS_CONFIG = {
+        "host": ...,
+        "password":...,
+        "port": ...,
+        "db": ...
+    }
+)
+...
+# 启动任务
+app.start()
+```
+### 3. 自定义请求
+`@app.request`使用装饰器封装自定义请求方法，作用于发生请求前的操作，返回Request对象或继承于BaseItem对象，用于控制请求参数。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Seed, Request, BaseItem
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.request
+def request(seed: Seed) -> Union[Request, BaseItem]:
+    # 可自定义headers，代理，构造请求参数等操作
+    proxies = {"http": ..., "https": ...}
+    yield Request(seed.url, seed, ..., proxies=proxies, timeout=15)
+    # yield xxxItem(seed, ...) # 跳过请求和解析直接进入数据存储流程
+    
+...
+
+app.start()
+```
+> 默认请求方法  
+> def request(seed: Seed) -> Union[Request, BaseItem]:  
+>     yield Request(seed.url, seed, timeout=5)
+### 4. 自定义下载
+`@app.download`使用装饰器封装自定义下载方法，作用于发生请求时的操作，返回Response对象或继承于BaseItem对象，用于控制请求参数。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Request, Response, BaseItem
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.download
+def download(item: Request) -> Union[BaseItem, Response]:
+    ...
+    response = ...
+    ...
+    yield Response(item.seed, response, ...) # 返回Response对象，进行解析
+    # yield xxxItem(seed, ...) # 跳过请求和解析直接进入数据存储流程
+    
+...
+
+app.start()
+```
+> 默认下载方法  
+> def download(item: Request) -> Union[Seed, BaseItem, Response, str]:  
+>     response = item.download()  
+>     yield Response(item.seed, response, **item.to_dict)
+### 5. 自定义解析
+自定义解析需要由一个存储数据类和解析方法组成。存储数据类继承于BaseItem的对象，规定存储表名及字段，
+解析方法返回继承于BaseItem的对象，yield返回进行控制数据存储流程。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Seed, Response, BaseItem
+
+class TestItem(BaseItem):
+    __TABLE__ = "test_data" # 表名
+    __FIELDS__ = "field1, field2, field3" # 字段名
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.parse
+def parse(item: Response) -> Union[Seed, BaseItem]:
+    ...
+    yield TestItem(item.seed, field1=..., field2=..., field3=...)
+    # yield Seed(...) # 构造新种子推送至消费队列
+    
+...
+
+app.start()
+```
+> 默认解析方法  
+> def parse(item: Request) -> Union[Seed, BaseItem]:  
+>     upload_item = item.to_dict  
+>     upload_item["text"] = item.response.text  
+>     yield ConsoleItem(item.seed, data=json.dumps(upload_item, ensure_ascii=False))
+## need deal
+- 队列优化完善，使用queue的机制wait()同步各模块执行？
+- 日志功能完善，单机模式调度和保存数据写入文件，结构化输出各任务日志
+- 去重过滤（布隆过滤器等）
+- 单机防丢失
+- excel、mysql、redis数据完善
+
+> 未更新流程图！！！
+![img.png](https://image-luyuan.oss-cn-hangzhou.aliyuncs.com/image/D2388CDC-B9E5-4CE4-9F2C-7D173763B6A8.png)
+
+

cobweb-launcher-1.2.1/README.md

@@ -0,0 +1,183 @@
+# cobweb 
+cobweb是一个基于python的分布式爬虫调度框架，目前支持分布式爬虫，单机爬虫，支持自定义数据库，支持自定义数据存储，支持自定义数据处理等操作。  
+
+cobweb主要由3个模块和一个配置文件组成：Launcher启动器、Crawler采集器、Pipeline存储和setting配置文件。
+1. Launcher启动器：用于启动爬虫任务，控制爬虫任务的执行流程，以及数据存储和数据处理。
+框架提供两种启动器模式：LauncherAir、LauncherPro，分别对应单机爬虫模式和分布式调度模式。
+2. Crawler采集器：用于控制采集流程、数据下载和数据处理。
+框架提供了基础的采集器，用于控制采集流程、数据下载和数据处理，用户也可在创建任务时自定义请求、下载和解析方法，具体看使用方法介绍。
+3. Pipeline存储：用于存储采集到的数据，支持自定义数据存储和数据处理。框架提供了Console和Loghub两种存储方式，用户也可继承Pipeline抽象类自定义存储方式。
+4. setting配置文件：用于配置采集器、存储器、队列长度、采集线程数等参数，框架提供了默认配置，用户也可自定义配置。
+## 安装
+```
+pip3 install --upgrade cobweb-launcher
+```
+## 使用方法介绍
+### 1. 任务创建
+- LauncherAir任务创建
+```python
+from cobweb import LauncherAir
+
+# 创建启动器
+app = LauncherAir(task="test", project="test")
+
+# 设置采集种子
+app.SEEDS = [{
+    "url": "https://www.baidu.com"
+}]
+...
+# 启动任务
+app.start()
+```
+- LauncherPro任务创建  
+LauncherPro依赖redis实现分布式调度，使用LauncherPro启动器需要完成环境变量的配置或自定义setting文件中的redis配置，如何配置查看`2. 自定义配置文件参数`
+```python
+from cobweb import LauncherPro
+
+# 创建启动器
+app = LauncherPro(
+    task="test",
+    project="test"
+)
+...
+# 启动任务
+app.start()
+```
+### 2. 自定义配置文件参数
+- 通过自定义setting文件，配置文件导入字符串方式  
+> 默认配置文件：import cobweb.setting  
+> 不推荐！！！目前有bug，随缘使用...
+例如：同级目录下自定义创建了setting.py文件。
+```python
+from cobweb import LauncherAir
+
+app = LauncherAir(
+    task="test", 
+    project="test",
+    setting="import setting"
+)
+
+...
+
+app.start()
+```
+- 自定义修改setting中对象值
+```python
+from cobweb import LauncherPro
+
+# 创建启动器
+app = LauncherPro(
+    task="test",
+    project="test",
+    REDIS_CONFIG = {
+        "host": ...,
+        "password":...,
+        "port": ...,
+        "db": ...
+    }
+)
+...
+# 启动任务
+app.start()
+```
+### 3. 自定义请求
+`@app.request`使用装饰器封装自定义请求方法，作用于发生请求前的操作，返回Request对象或继承于BaseItem对象，用于控制请求参数。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Seed, Request, BaseItem
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.request
+def request(seed: Seed) -> Union[Request, BaseItem]:
+    # 可自定义headers，代理，构造请求参数等操作
+    proxies = {"http": ..., "https": ...}
+    yield Request(seed.url, seed, ..., proxies=proxies, timeout=15)
+    # yield xxxItem(seed, ...) # 跳过请求和解析直接进入数据存储流程
+    
+...
+
+app.start()
+```
+> 默认请求方法  
+> def request(seed: Seed) -> Union[Request, BaseItem]:  
+>     yield Request(seed.url, seed, timeout=5)
+### 4. 自定义下载
+`@app.download`使用装饰器封装自定义下载方法，作用于发生请求时的操作，返回Response对象或继承于BaseItem对象，用于控制请求参数。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Request, Response, BaseItem
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.download
+def download(item: Request) -> Union[BaseItem, Response]:
+    ...
+    response = ...
+    ...
+    yield Response(item.seed, response, ...) # 返回Response对象，进行解析
+    # yield xxxItem(seed, ...) # 跳过请求和解析直接进入数据存储流程
+    
+...
+
+app.start()
+```
+> 默认下载方法  
+> def download(item: Request) -> Union[Seed, BaseItem, Response, str]:  
+>     response = item.download()  
+>     yield Response(item.seed, response, **item.to_dict)
+### 5. 自定义解析
+自定义解析需要由一个存储数据类和解析方法组成。存储数据类继承于BaseItem的对象，规定存储表名及字段，
+解析方法返回继承于BaseItem的对象，yield返回进行控制数据存储流程。
+```python
+from typing import Union
+from cobweb import LauncherAir
+from cobweb.base import Seed, Response, BaseItem
+
+class TestItem(BaseItem):
+    __TABLE__ = "test_data" # 表名
+    __FIELDS__ = "field1, field2, field3" # 字段名
+
+app = LauncherAir(
+    task="test", 
+    project="test"
+)
+
+...
+
+@app.parse
+def parse(item: Response) -> Union[Seed, BaseItem]:
+    ...
+    yield TestItem(item.seed, field1=..., field2=..., field3=...)
+    # yield Seed(...) # 构造新种子推送至消费队列
+    
+...
+
+app.start()
+```
+> 默认解析方法  
+> def parse(item: Request) -> Union[Seed, BaseItem]:  
+>     upload_item = item.to_dict  
+>     upload_item["text"] = item.response.text  
+>     yield ConsoleItem(item.seed, data=json.dumps(upload_item, ensure_ascii=False))
+## need deal
+- 队列优化完善，使用queue的机制wait()同步各模块执行？
+- 日志功能完善，单机模式调度和保存数据写入文件，结构化输出各任务日志
+- 去重过滤（布隆过滤器等）
+- 单机防丢失
+- excel、mysql、redis数据完善
+
+> 未更新流程图！！！
+![img.png](https://image-luyuan.oss-cn-hangzhou.aliyuncs.com/image/D2388CDC-B9E5-4CE4-9F2C-7D173763B6A8.png)

cobweb-launcher-1.2.1/cobweb/__init__.py

@@ -0,0 +1,2 @@
+from .launchers import LauncherAir, LauncherPro
+from .constant import CrawlerModel

{cobweb-launcher-1.1.23 → cobweb-launcher-1.2.1}/cobweb/base/__init__.py

@@ -1,7 +1,7 @@
 from .common_queue import Queue
 from .response import Response
 from .request import Request
-from .item import BaseItem
+from .item import BaseItem, ConsoleItem
 from .seed import Seed
 
 from .log import logger

{cobweb-launcher-1.1.23 → cobweb-launcher-1.2.1}/cobweb/base/item.py

@@ -37,3 +37,10 @@ class BaseItem(metaclass=Item):
     @property
     def table(self):
         return self.Data.__name__
+
+
+class ConsoleItem(BaseItem):
+
+    __TABLE__ = "console"
+    __FIELDS__ = "data"
+

{cobweb-launcher-1.1.23 → cobweb-launcher-1.2.1}/cobweb/constant.py

@@ -30,6 +30,24 @@ class DealModel:
 
 class LogTemplate:
 
+    console_item = """
+    ----------------------- start - console pipeline -----------------
+            种子详情 \n{seed_detail}
+            解析详情 \n{parse_detail}
+    ----------------------- end  - console pipeline ------------------
+    """
+
+    launcher_air_polling = """
+    ----------------------- start - 轮训日志: {task} -----------------
+            内存队列 
+                种子数:  {doing_len}
+                待消费:  {todo_len}
+                已消费:  {done_len}
+            存储队列 
+                待上传:  {upload_len}
+    ----------------------- end  - 轮训日志: {task} ------------------
+    """
+
     launcher_pro_polling = """
 ----------------------- start - 轮训日志: {task} -----------------
         内存队列 
@@ -69,4 +87,8 @@ class LogTemplate:
         response 
             status        :    {status} \n{response}
 ------------------------------------------------------------------
-"""
+"""
+
+    @staticmethod
+    def log_info(item: dict) -> str:
+        return "\n".join([" " * 12 + f"{str(k).ljust(14)}:    {str(v)}" for k, v in item.items()])

cobweb-launcher-1.2.1/cobweb/crawlers/__init__.py

@@ -0,0 +1 @@
+from .crawler import Crawler

cobweb-launcher-1.1.23/cobweb/crawlers/base_crawler.py → cobweb-launcher-1.2.1/cobweb/crawlers/crawler.py

@@ -1,40 +1,52 @@
+import json
 import threading
 import time
 import traceback
-
 from inspect import isgenerator
 from typing import Union, Callable, Mapping
 
-from cobweb.base import Queue, Seed, BaseItem, Request, Response, logger
 from cobweb.constant import DealModel, LogTemplate
-from cobweb.utils import download_log_info
-from cobweb import setting
+from cobweb.base import (
+    Queue, 
+    Seed, 
+    BaseItem, 
+    Request, 
+    Response, 
+    ConsoleItem,
+    logger
+)
 
 
 class Crawler(threading.Thread):
 
     def __init__(
             self,
-            upload_queue: Queue,
-            custom_func: Union[Mapping[str, Callable]],
+            stop: threading.Event,
+            pause: threading.Event,
             launcher_queue: Union[Mapping[str, Queue]],
+            custom_func: Union[Mapping[str, Callable]],
+            thread_num: int,
+            max_retries: int
     ):
         super().__init__()
 
-        self.upload_queue = upload_queue
+        self._stop = stop
+        self._pause = pause
+        self._new = launcher_queue["new"]
+        self._todo = launcher_queue["todo"]
+        self._done = launcher_queue["done"]
+        self._upload = launcher_queue["upload"]
+
         for func_name, _callable in custom_func.items():
             if isinstance(_callable, Callable):
                 self.__setattr__(func_name, _callable)
 
-        self.launcher_queue = launcher_queue
-
-        self.spider_thread_num = setting.SPIDER_THREAD_NUM
-        self.max_retries = setting.SPIDER_MAX_RETRIES
+        self.thread_num = thread_num
+        self.max_retries = max_retries
 
     @staticmethod
     def request(seed: Seed) -> Union[Request, BaseItem]:
-        stream = True if setting.DOWNLOAD_MODEL else False
-        yield Request(seed.url, seed, stream=stream, timeout=5)
+        yield Request(seed.url, seed, timeout=5)
 
     @staticmethod
     def download(item: Request) -> Union[Seed, BaseItem, Response, str]:
@@ -43,39 +55,43 @@ class Crawler(threading.Thread):
 
     @staticmethod
     def parse(item: Response) -> BaseItem:
-        pass
+        upload_item = item.to_dict
+        upload_item["text"] = item.response.text
+        yield ConsoleItem(item.seed, data=json.dumps(upload_item, ensure_ascii=False))
 
-    def get_seed(self) -> Seed:
-        return self.launcher_queue['todo'].pop()
+    # def get_seed(self) -> Seed:
+    #     return self._todo.pop()
 
     def distribute(self, item, seed):
         if isinstance(item, BaseItem):
-            self.upload_queue.push(item)
+            self._upload.push(item)
         elif isinstance(item, Seed):
-            self.launcher_queue['new'].push(item)
+            self._new.push(item)
         elif isinstance(item, str) and item == DealModel.poll:
-            self.launcher_queue['todo'].push(seed)
+            self._todo.push(seed)
         elif isinstance(item, str) and item == DealModel.done:
-            self.launcher_queue['done'].push(seed)
+            self._done.push(seed)
         elif isinstance(item, str) and item == DealModel.fail:
             seed.params.seed_status = DealModel.fail
-            self.launcher_queue['done'].push(seed)
+            self._done.push(seed)
         else:
             raise TypeError("yield value type error!")
 
     def spider(self):
-        while True:
-            seed = self.get_seed()
+        while not self._stop.is_set():
+
+            seed = self._todo.pop()
 
             if not seed:
+                time.sleep(1)
                 continue
 
             elif seed.params.retry >= self.max_retries:
                 seed.params.seed_status = DealModel.fail
-                self.launcher_queue['done'].push(seed)
+                self._done.push(seed)
                 continue
 
-            seed_detail_log_info = download_log_info(seed.to_dict)
+            seed_detail_log_info = LogTemplate.log_info(seed.to_dict)
 
             try:
                 request_iterators = self.request(seed)
@@ -106,7 +122,7 @@ class Crawler(threading.Thread):
                                     seed_version=seed.params.seed_version,
                                     identifier=seed.identifier or "",
                                     status=download_item.response,
-                                    response=download_log_info(download_item.to_dict)
+                                    response=LogTemplate.log_info(download_item.to_dict)
                                 ))
                                 parse_iterators = self.parse(download_item)
                                 if not isgenerator(parse_iterators):
@@ -123,7 +139,6 @@ class Crawler(threading.Thread):
 
                 if not iterator_status:
                     raise ValueError("request/download/parse function yield value error!")
-
             except Exception as e:
                 logger.info(LogTemplate.download_exception.format(
                     detail=seed_detail_log_info,
@@ -134,11 +149,12 @@ class Crawler(threading.Thread):
                     exception=''.join(traceback.format_exception(type(e), e, e.__traceback__))
                 ))
                 seed.params.retry += 1
-                self.launcher_queue['todo'].push(seed)
+                self._todo.push(seed)
             finally:
                 time.sleep(0.1)
+        logger.info("spider thread close")
 
     def run(self):
-        for index in range(self.spider_thread_num):
+        for index in range(self.thread_num):
             threading.Thread(name=f"spider_{index}", target=self.spider).start()
 

{cobweb-launcher-1.1.23 → cobweb-launcher-1.2.1}/cobweb/launchers/__init__.py

@@ -1,2 +1,2 @@
-from .launcher import Launcher
+from .launcher_air import LauncherAir
 from .launcher_pro import LauncherPro