nosp 0.8.1__tar.gz

nosp-0.8.1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: nosp
+Version: 0.8.1
+Author-email: noybzy <noybzy@qq.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: dbutils==3.1.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: parsel==1.10.0
+Requires-Dist: pymysql==1.1.1
+Requires-Dist: requests>=2.32.3
+
+# NOSP：轻量爬取工具
+
+**NOSP** 是一个轻量级、模块化的 Python 框架，专为高效的网络爬取而设计。它为开发者提供了构建健壮且可扩展的网络爬虫所需的基本工具，同时处理常见的技术挑战，如并发、HTTP 请求、内容解析和数据存储。
+
+作为一个专门的工具包，NOSP 通过提供预构建的组件，简化了复杂的爬取流程，帮助开发者专注于数据提取，而非底层实现细节。
+
+------
+
+## 主要特性
+
+| 特性              | 描述                                                    |
+| ----------------- | ------------------------------------------------------- |
+| **多线程爬取**    | 内置线程池管理，支持高效并发操作                        |
+| **HTTP 请求处理** | 强大的请求管理，支持重试机制、代理配置、请求/响应拦截器 |
+| **内容解析**      | 基于 XPath 的强大内容提取工具，支持结构化数据抽取       |
+| **数据库集成**    | 直接集成 MySQL 和 Redis，支持便捷的数据存储与缓存       |
+| **错误处理**      | 全面的异常管理机制，确保爬虫在异常情况下的稳定性与韧性  |
+| **资源提取**      | 提供专用工具，用于从网页中提取附件、图片等二进制资源    |
+
+------
+
+## 框架架构
+
+NOSP 采用**模块化设计**，将关注点分离到独立组件中，同时保持清晰的接口定义。这种设计允许开发者按需使用特定模块，提升灵活性与可维护性。
+
+### 核心组件
+
+- **`BaseSpider` 类**：框架的核心，负责协调爬取工作流程，调度请求、解析与存储。
+- **模块化结构**：各功能模块（如请求、解析、存储）松耦合，易于替换或扩展。
+
+------
+
+## 何时使用 NOSP？
+
+NOSP 在以下场景中特别有价值：
+
+- ✅ 需要构建**可维护、结构化**的网络爬虫
+- ✅ 项目要求**高效率**，需支持并发操作
+- ✅ 希望避免重复实现常见功能（如代理管理、解析逻辑、数据存储）
+- ✅ 需要一个**灵活可扩展**的基础框架，适应不同爬取需求
+
+> **适用范围**：既适用于简单的数据抓取任务，也足以支撑复杂的生产级爬虫系统。
+
+------
+
+## 核心概念
+
+NOSP 围绕以下核心概念构建，理解这些概念是高效使用框架的关键：
+
+| 概念                | 说明                                                         |
+| ------------------- | ------------------------------------------------------------ |
+| **爬虫 (Spider)**   | 协调整个爬取流程的核心类，定义起始 URL、解析逻辑和后续请求   |
+| **请求 (Request)**  | 封装 HTTP 请求，支持自定义 headers、cookies、代理、重试等    |
+| **解析器 (Parser)** | 负责从网页 HTML 内容中提取结构化数据，支持 XPath 和正则表达式 |
+| **存储 (Storage)**  | 处理爬取数据的持久化，支持写入数据库（MySQL/Redis）或本地文件 |

nosp-0.8.1/README.md

@@ -0,0 +1,55 @@
+# NOSP：轻量爬取工具
+
+**NOSP** 是一个轻量级、模块化的 Python 框架，专为高效的网络爬取而设计。它为开发者提供了构建健壮且可扩展的网络爬虫所需的基本工具，同时处理常见的技术挑战，如并发、HTTP 请求、内容解析和数据存储。
+
+作为一个专门的工具包，NOSP 通过提供预构建的组件，简化了复杂的爬取流程，帮助开发者专注于数据提取，而非底层实现细节。
+
+------
+
+## 主要特性
+
+| 特性              | 描述                                                    |
+| ----------------- | ------------------------------------------------------- |
+| **多线程爬取**    | 内置线程池管理，支持高效并发操作                        |
+| **HTTP 请求处理** | 强大的请求管理，支持重试机制、代理配置、请求/响应拦截器 |
+| **内容解析**      | 基于 XPath 的强大内容提取工具，支持结构化数据抽取       |
+| **数据库集成**    | 直接集成 MySQL 和 Redis，支持便捷的数据存储与缓存       |
+| **错误处理**      | 全面的异常管理机制，确保爬虫在异常情况下的稳定性与韧性  |
+| **资源提取**      | 提供专用工具，用于从网页中提取附件、图片等二进制资源    |
+
+------
+
+## 框架架构
+
+NOSP 采用**模块化设计**，将关注点分离到独立组件中，同时保持清晰的接口定义。这种设计允许开发者按需使用特定模块，提升灵活性与可维护性。
+
+### 核心组件
+
+- **`BaseSpider` 类**：框架的核心，负责协调爬取工作流程，调度请求、解析与存储。
+- **模块化结构**：各功能模块（如请求、解析、存储）松耦合，易于替换或扩展。
+
+------
+
+## 何时使用 NOSP？
+
+NOSP 在以下场景中特别有价值：
+
+- ✅ 需要构建**可维护、结构化**的网络爬虫
+- ✅ 项目要求**高效率**，需支持并发操作
+- ✅ 希望避免重复实现常见功能（如代理管理、解析逻辑、数据存储）
+- ✅ 需要一个**灵活可扩展**的基础框架，适应不同爬取需求
+
+> **适用范围**：既适用于简单的数据抓取任务，也足以支撑复杂的生产级爬虫系统。
+
+------
+
+## 核心概念
+
+NOSP 围绕以下核心概念构建，理解这些概念是高效使用框架的关键：
+
+| 概念                | 说明                                                         |
+| ------------------- | ------------------------------------------------------------ |
+| **爬虫 (Spider)**   | 协调整个爬取流程的核心类，定义起始 URL、解析逻辑和后续请求   |
+| **请求 (Request)**  | 封装 HTTP 请求，支持自定义 headers、cookies、代理、重试等    |
+| **解析器 (Parser)** | 负责从网页 HTML 内容中提取结构化数据，支持 XPath 和正则表达式 |
+| **存储 (Storage)**  | 处理爬取数据的持久化，支持写入数据库（MySQL/Redis）或本地文件 |

nosp-0.8.1/nosp/__init__.py

@@ -0,0 +1,2 @@
+from .monitor import *
+from .core import *

nosp-0.8.1/nosp/cache.py

@@ -0,0 +1,104 @@
+import sys
+from typing import Optional, Callable, Any, Dict, TypeVar, Generic
+
+from loguru import logger
+
+from nosp.config import RedisConfig
+from nosp.database import Redis
+from nosp.utils import get_md5
+
+
+class CacheBaseModel:
+    def __init__(self):
+        self._on_change: Optional[Callable[[str, str], None]] = None
+        self._on_get: Optional[Callable[[str], str]] = None
+        self._live = False
+
+    def __init_subclass__(cls):
+        cls._on_change: Optional[Callable[[str, str], None]] = None
+        cls._on_get: Optional[Callable[[str], str]] = None
+        cls._live = False
+
+    def on_change(self, callback: Callable[[str, str], None]) -> None:
+        """注册变更回调"""
+        self._on_change = callback
+
+    def on_get(self, callback: Callable[[str], str]) -> None:
+        """注册Get回调"""
+        self._on_get = callback
+
+    def __setattr__(self, key: str, value: Any):
+        super().__setattr__(key, value)
+        if not key.startswith("_") and hasattr(self, '_on_change') and self._on_change is not None:
+            self._on_change(key, str(value))
+
+    def __getattribute__(self, key: str) -> Any:
+        if key.startswith("_"):
+            return super().__getattribute__(key)
+
+        if hasattr(self, '_live') and self._live and hasattr(self, '_on_get') and self._on_get is not None:
+            try:
+                result = self._on_get(key)
+                if result is None and super().__getattribute__(key) is not None:
+                    return super().__getattribute__(key)
+                return self._on_get(key)
+            except Exception as e:
+                logger.warning(f"on_get({key}) failed: {e}")
+
+        return super().__getattribute__(key)
+
+    def set(self, data: Dict[str, Any]):
+        annotations = self.__class__.__annotations__
+        for k, v in data.items():
+            if k in annotations:
+                setattr(self, k, v)
+
+    def get(self) -> Dict[str, str]:
+        return {
+            k: str(getattr(self, k))
+            for k in self._class__.__annotations__
+            if hasattr(self, k)
+        }
+
+
+T = TypeVar('T', bound=CacheBaseModel)
+
+
+class Cache(Generic[T]):
+    def __init__(self, cfg: RedisConfig, db=15, data_type=None, live=False, key=None):
+        self.key = key if key else get_md5(sys.modules.get("__main__").__file__)
+        self.redis = Redis.simple(cfg, db=db)
+        self.data: Optional[T] = None
+        if data_type is not None:
+            self.data: Optional[T] = data_type()
+            self._load()
+            self.data._live = live
+
+    def _save_to_redis(self, key, value):
+        """私有方法：保存数据到 Redis"""
+        try:
+            self.redis.r.hset(self.key, key, value)
+        except Exception as e:
+            logger.warning(f"Save failed: {e}")
+
+    def _on_get(self, key: str) -> str:
+        return self.redis.r.hget(self.key, key)
+
+    def _load(self):
+        if self.data is None:
+            return None
+        data = self.redis.r.hgetall(self.key)
+        if data and isinstance(data, dict):
+            try:
+                self.data.set(data)
+            except Exception as e:
+                logger.warning(f"Load failed: {e}")
+        self.data.on_change(self._save_to_redis)
+        self.data.on_get(self._on_get)
+        return None
+
+    def get(self, key: str) -> str:
+        return self.redis.r.hget(self.key, key)
+
+    def set(self, key: str, value):
+        return self.redis.r.hset(self.key, key, value)

nosp-0.8.1/nosp/config.py

@@ -0,0 +1,34 @@
+class MysqlConfig(object):
+    def __init__(self, host: str, port: int, username: str, password: str, db: str, charset: str = 'utf8mb4'):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.db = db
+        self.charset = charset
+
+
+class RedisConfig(object):
+    def __init__(self, host: str, port: int, password: str, db: int):
+        self.host = host
+        self.port = port
+        self.password = password
+        self.db = db
+
+
+class RabbitMQConfig(object):
+    def __init__(self, host: str, port: int, username: str, password: str, virtual_host: str = '/'):
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.virtual_host = virtual_host
+
+
+class OssConfig(object):
+    def __init__(self, access_key: str, access_secret: str, endpoint: str, bucket_name: str, region: str = None):
+        self.access_key = access_key
+        self.access_secret = access_secret
+        self.endpoint = endpoint
+        self.bucket_name = bucket_name
+        self.region = region

nosp-0.8.1/nosp/core.py

@@ -0,0 +1,41 @@
+import os
+import sys
+from pathlib import Path
+
+
+def load_path():
+    """
+    向上查找 [config.py or pyproject.toml] 所在目录，并将其添加到 sys.path 中。
+    """
+    current_dir = Path(sys.modules.get("__main__").__file__).resolve().parent
+    root_dir = None
+    for parent in [current_dir, *current_dir.parents]:
+        if (parent / "config.py").exists() or (parent / "pyproject.toml").exists():
+            root_dir = parent
+            break
+    if root_dir is not None:
+        root_path = str(root_dir)
+        if sys.path[0] != root_path:
+            sys.path.insert(0, root_path)
+            print(f"[load_path] 添加路径到 sys.path: {root_path}")
+    else:
+        print("[load_path] 未找到 config.py 或 pyproject.toml，未修改 sys.path。")
+
+
+
+def load_env(filepath='.env'):
+    """
+    从指定路径读取 .env 文件，并将变量加载到 os.environ 中。
+    :param filepath: .env 文件路径，默认为当前目录下的 .env
+    """
+    if not os.path.isfile(filepath):
+        return
+
+    with open(filepath, encoding='utf-8') as file:
+        for line in file:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            if '=' in line:
+                key, value = line.split('=', 1)
+                os.environ[key] = value.strip('"\' ')