cnks 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

src/cssci.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+CSSCI筛选模块 (China Social Sciences Citation Index Filter)
+
+这个模块负责在知网等学术搜索页面中查找并勾选CSSCI来源类别筛选选项。
+CSSCI（中文社会科学引文索引）是一个重要的中文社科类期刊评价体系。
+
+主要职责:
+1. 在搜索结果页面中定位来源类别筛选区域
+2. 查找并勾选CSSCI复选框
+3. 应用筛选并等待结果加载
+"""
+
+import logging
+import traceback
+import asyncio
+from typing import Dict, Any
+
+# 获取logger
+logger = logging.getLogger("cnks.cssci")
+
+js_button_finder = """
+() => {
+    try {
+        // 首先尝试找到带有"CSSCI"文本的链接
+        let foundElement = null;
+        
+        // 尝试查找带有title="CSSCI"的链接
+        const cssciLinks = document.querySelectorAll('a[title="CSSCI"]');
+        if (cssciLinks.length > 0) {
+            foundElement = cssciLinks[0];
+            return {
+                found: true,
+                x: foundElement.getBoundingClientRect().left + foundElement.getBoundingClientRect().width/2,
+                y: foundElement.getBoundingClientRect().top + foundElement.getBoundingClientRect().height/2,
+                method: 'title_link',
+                message: "找到带有title='CSSCI'的链接元素"
+            };
+        }
+        
+        // 尝试查找包含CSSCI文本的链接
+        const allLinks = document.querySelectorAll('a');
+        for (const link of allLinks) {
+            if (link.textContent && link.textContent.trim() === 'CSSCI') {
+                foundElement = link;
+                return {
+                    found: true,
+                    x: foundElement.getBoundingClientRect().left + foundElement.getBoundingClientRect().width/2,
+                    y: foundElement.getBoundingClientRect().top + foundElement.getBoundingClientRect().height/2,
+                    method: 'text_link',
+                    message: "找到文本为'CSSCI'的链接元素"
+                };
+            }
+        }
+        
+        // 尝试查找包含CSSCI文本的任何元素
+        const allElements = document.querySelectorAll('*');
+        for (const element of allElements) {
+            if (element.textContent && 
+                element.textContent.includes('CSSCI') && 
+                element.getBoundingClientRect().width > 0 &&
+                element.getBoundingClientRect().height > 0) {
+                foundElement = element;
+                return {
+                    found: true,
+                    x: foundElement.getBoundingClientRect().left + foundElement.getBoundingClientRect().width/2,
+                    y: foundElement.getBoundingClientRect().top + foundElement.getBoundingClientRect().height/2,
+                    method: 'any_element',
+                    message: "找到包含'CSSCI'的元素"
+                };
+            }
+        }
+        
+        // 未找到任何相关元素
+        return {
+            found: false,
+            message: "未找到任何包含'CSSCI'的可点击元素"
+        };
+    } catch (error) {
+        // 发生错误，返回错误信息
+        return {
+            found: false,
+            error: error.toString(),
+            message: "查找CSSCI元素时发生错误: " + error.toString()
+        };
+    }
+}
+"""
+
+async def apply_cssci_filter(page) -> Dict[str, Any]:
+    """
+    在搜索结果页面中应用CSSCI筛选
+    
+    Args:
+        page: Playwright页面对象
+        
+    Returns:
+        Dict: 包含操作结果的字典，包括是否成功、消息等
+    """
+    logger.info("开始应用CSSCI筛选")
+    result = {
+        "success": True,  # 默认为True，即使没找到也算成功（跳过继续处理）
+        "message": "",
+        "filter_applied": False
+    }
+    
+    try:
+        # 使用JavaScript查找CSSCI元素
+        cssci_result = await page.evaluate(js_button_finder)
+        logger.info(f"CSSCI元素查找结果: {cssci_result}")
+        
+        if cssci_result.get('found', False):
+            logger.info(f"通过方法 '{cssci_result.get('method', 'unknown')}' 找到CSSCI元素，准备点击")
+            
+            # 使用鼠标点击坐标来模拟点击
+            x, y = cssci_result.get('x'), cssci_result.get('y')
+            await page.mouse.click(x, y)
+            logger.info(f"已点击坐标 ({x}, {y}) 处的CSSCI元素")
+            
+            # 点击后等待短暂时间让页面响应，但不主动刷新
+            await page.wait_for_timeout(1000)  # 等待1秒，让页面有时间响应
+            
+            result["filter_applied"] = True
+            result["message"] = f"成功点击CSSCI元素（{cssci_result.get('method', 'unknown')}方法），由页面自行处理更新"
+        else:
+            # 如果没找到CSSCI元素，记录消息但仍然继续处理
+            result["message"] = cssci_result.get('message', "未找到CSSCI元素，跳过筛选步骤")
+            logger.info(result["message"])
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"应用CSSCI筛选时发生错误: {str(e)}")
+        logger.error(traceback.format_exc())
+        
+        result["message"] = f"应用CSSCI筛选时发生错误: {str(e)}"
+        return result
+
+async def _click_apply_button(page):
+    """
+    尝试点击筛选按钮以应用筛选
+    
+    Args:
+        page: Playwright页面对象
+    """
+    # 等待一秒，确保页面状态已更新
+    await asyncio.sleep(1)
+    
+    apply_buttons = [
+        '.filter-button', 
+        '.apply-filter', 
+        'button[text="筛选"]',
+        'button[text="应用"]',
+        'button[text="确定"]',
+        'input[type="button"][value="确定"]',
+        '.btn-primary',
+        '#btn_search'
+    ]
+    
+    for btn_selector in apply_buttons:
+        try:
+            button = await page.query_selector(btn_selector)
+            if button:
+                logger.info(f"点击筛选应用按钮: {btn_selector}")
+                await button.click()
+                await page.wait_for_load_state("networkidle", timeout=10000)
+                return True
+        except Exception as e:
+            logger.warning(f"点击按钮 '{btn_selector}' 失败: {str(e)}")
+    
+    # 如果没有找到标准按钮，尝试通过JavaScript应用筛选
+    logger.info("尝试通过JavaScript应用筛选")
+    apply_js = """
+    () => {
+        try {
+            // 尝试找到并点击筛选应用按钮
+            const buttons = document.querySelectorAll('button, input[type="button"], a.btn');
+            for (const button of buttons) {
+                if (button.textContent && 
+                    (button.textContent.includes('筛选') || 
+                     button.textContent.includes('应用') || 
+                     button.textContent.includes('确定') ||
+                     button.textContent.includes('搜索'))) {
+                    button.click();
+                    return { clicked: true, text: button.textContent.trim() };
+                }
+            }
+            
+            // 尝试查找搜索按钮
+            const searchBtn = document.querySelector('#btn_search, .search-button, button[onclick*="search"]');
+            if (searchBtn) {
+                searchBtn.click();
+                return { clicked: true, type: 'search' };
+            }
+            
+            // 尝试提交表单
+            const form = document.querySelector('form');
+            if (form) {
+                form.submit();
+                return { clicked: true, type: 'form' };
+            }
+            
+            return { clicked: false };
+        } catch (e) {
+            return { clicked: false, error: e.toString() };
+        }
+    }
+    """
+    
+    apply_result = await page.evaluate(apply_js)
+    if apply_result.get('clicked', False):
+        logger.info(f"通过JavaScript应用筛选成功: {apply_result}")
+        await page.wait_for_load_state("networkidle", timeout=10000)
+        return True
+    
+    logger.warning("未找到应用筛选的按钮")
+    return False
+
+
+# 用于独立测试的函数
+async def test_cssci_filter(page_url):
+    """
+    独立测试CSSCI筛选功能
+    
+    Args:
+        page_url: 要测试的页面URL
+    """
+    from playwright.async_api import async_playwright
+    
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=False)
+        page = await browser.new_page()
+        
+        try:
+            await page.goto(page_url, wait_until="domcontentloaded")
+            await page.wait_for_load_state("networkidle")
+            
+            result = await apply_cssci_filter(page)
+            print(f"测试结果: {result}")
+            
+            # 截图保存结果
+            await page.screenshot(path="cssci_filter_test.png")
+            print("已保存测试结果截图")
+            
+            # 等待查看结果
+            await asyncio.sleep(5)
+            
+        finally:
+            await browser.close()
+
+# 如果直接运行脚本
+if __name__ == "__main__":
+    import sys
+    
+    # 配置日志
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    # 获取命令行参数或使用默认URL
+    url = sys.argv[1] if len(sys.argv) > 1 else "https://kns.cnki.net/kns8s/search"
+    
+    print(f"测试在页面 {url} 上应用CSSCI筛选")
+    asyncio.run(test_cssci_filter(url)) 

src/extractlink.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+链接提取模块（Extract Link Module）
+
+这是一个独立处理链接提取的模块，专门负责从知网搜索结果中提取有效的文章链接。
+使用多种选择器和模式匹配技术提取文章链接，确保提取到实际文章页面而非导航页。
+
+主要职责:
+1. 分析知网搜索结果页面结构
+2. 提取文章详情和摘要链接
+3. 过滤非文章链接
+4. 返回有效的文章链接列表
+"""
+
+import logging
+import traceback
+import re
+from typing import List, Dict, Any
+
+# 设置日志记录器
+logger = logging.getLogger("cnks.extractlink")
+
+async def extract_links_from_page(page) -> List[str]:
+    """
+    从知网搜索结果页面提取文章链接
+    
+    Args:
+        page: Playwright页面对象
+        
+    Returns:
+        List[str]: 提取到的文章链接列表
+    """
+    logger.info("开始从页面提取文章链接")
+    
+    try:
+        # 首先尝试使用更精确的选择器直接查找文章链接
+        specific_selectors = [
+            # 知网常见文章链接选择器
+            '.result-table-list .result-table-item .left a.fz14',  # 新版知网结果列表
+            '.search-result .dl_li .t_title a',                    # 部分旧版结果列表
+            '.result-list .article-item h3 a',                     # 另一版本
+            '.searchresult .list_item .title a',                   # 再一版本
+            '.resultlist .item_title a',                           # 另一种可能格式
+            'a[href*="/detail/abstract?"]',                        # 包含abstract的链接
+            'a[href*="/article/detail?"]',                         # 包含article/detail的链接
+            'a[href*="dbcode="]',                                  # 包含dbcode参数的链接
+        ]
+        
+        # 使用JavaScript执行提取逻辑
+        js_extract = """
+        (selectors) => {
+            const results = {
+                links: [],
+                debug: {}
+            };
+            
+            // 收集各选择器匹配数量作为调试信息
+            for (const selector of selectors) {
+                const elements = document.querySelectorAll(selector);
+                results.debug[selector] = elements.length;
+                
+                for (const el of elements) {
+                    const href = el.getAttribute('href');
+                    if (href && !href.includes('javascript:') && !href.includes('mailto:')) {
+                        // 收集链接和相关文本信息帮助验证
+                        results.links.push({
+                            url: href,
+                            text: el.textContent.trim(),
+                            selector: selector
+                        });
+                    }
+                }
+            }
+            
+            // 如果上述选择器没有找到任何链接，尝试一个更通用但不太精确的方法
+            if (results.links.length === 0) {
+                // 查找所有链接并分析
+                const allLinks = document.querySelectorAll('a');
+                results.debug['allLinks'] = allLinks.length;
+                
+                for (const link of allLinks) {
+                    const href = link.getAttribute('href');
+                    const text = link.textContent.trim();
+                    
+                    // 检查链接是否可能是文章链接
+                    if (href && 
+                        !href.includes('javascript:') && 
+                        !href.includes('mailto:') &&
+                        (href.includes('/detail/') || 
+                         href.includes('/article/') || 
+                         href.includes('cnki.net') && href.includes('dbcode=') ||
+                         text.length > 10 && !link.querySelector('img') && // 长文本且不包含图片可能是标题
+                         !href.includes('/index') && // 排除导航链接
+                         !href.includes('/search') && // 排除搜索链接
+                         !href.includes('/help'))) {  // 排除帮助链接
+                        
+                        results.links.push({
+                            url: href,
+                            text: text,
+                            selector: 'generic'
+                        });
+                    }
+                }
+            }
+            
+            // 如果仍然没有找到链接，记录页面结构用于调试
+            if (results.links.length === 0) {
+                results.debug.html = document.body.innerHTML.substring(0, 5000); // 前5000字符
+            }
+            
+            return results;
+        }
+        """
+        
+        # 执行JavaScript获取链接
+        extract_result = await page.evaluate(js_extract, specific_selectors)
+        
+        # 分析提取结果
+        if not extract_result.get('links'):
+            logger.warning("未找到任何文章链接")
+            # 记录选择器匹配情况
+            for selector, count in extract_result.get('debug', {}).items():
+                if selector != 'html':  # 不打印HTML内容
+                    logger.debug(f"选择器 '{selector}' 匹配到 {count} 个元素")
+            
+            # 进行截图以便分析
+            screenshot_path = "search_results.png"
+            await page.screenshot(path=screenshot_path)
+            logger.info(f"已保存搜索结果页面截图到 {screenshot_path}")
+            
+            # 如果提供了HTML调试信息
+            if 'html' in extract_result.get('debug', {}):
+                logger.debug("页面结构片段:\n" + extract_result['debug']['html'][:500] + "...")
+            
+            return []
+        
+        # 从返回的对象中提取URL
+        raw_links = [item['url'] for item in extract_result['links']]
+        logger.info(f"初步提取到 {len(raw_links)} 个链接")
+        
+        # 确保所有链接是绝对URL
+        page_url = page.url
+        processed_links = []
+        for link in raw_links:
+            # 如果是相对链接，转换为绝对链接
+            if not link.startswith('http'):
+                if link.startswith('/'):
+                    # 从页面URL获取基本域名
+                    match = re.match(r'(https?://[^/]+)', page_url)
+                    if match:
+                        base_url = match.group(1)
+                        absolute_link = base_url + link
+                        processed_links.append(absolute_link)
+                        continue
+                # 如果无法处理，跳过
+                logger.warning(f"无法处理相对链接: {link}")
+                continue
+            
+            processed_links.append(link)
+        
+        # 过滤处理后的链接
+        filtered_links = filter_article_links(processed_links)
+        logger.info(f"过滤后保留 {len(filtered_links)} 个有效文章链接")
+        
+        # 打印样本链接进行分析
+        if filtered_links:
+            sample_size = min(5, len(filtered_links))
+            sample_links = filtered_links[:sample_size]
+            logger.info(f"样本链接分析:")
+            for i, link in enumerate(sample_links):
+                logger.info(f"样本 {i+1}: {link}")
+        
+        return filtered_links
+        
+    except Exception as e:
+        logger.error(f"提取链接时出错: {str(e)}")
+        logger.error(traceback.format_exc())
+        return []
+
+def filter_article_links(links: List[str]) -> List[str]:
+    """
+    过滤链接列表，只保留可能的知网文章链接
+    
+    Args:
+        links: 需要过滤的链接列表
+        
+    Returns:
+        List[str]: 过滤后的文章链接列表
+    """
+    # 知网文章URL的常见模式
+    article_patterns = [
+        # 常见知网文章地址模式
+        r'kns\.cnki\.net/([^/]+/)+detail/abstract',
+        r'kns\.cnki\.net/([^/]+/)*article/detail',
+        r'cnki\.net/kcms/detail/detail\.aspx',
+        r'cnki\.net/KCMS/detail/detail\.aspx',
+        r'cnki\.net/.*?dbcode=',
+        r'academic\.cnki\.net/.*?doi=',
+        r'cnki\.com\.cn/Article/CJFDTotal-',
+        # 排除明确不是文章的链接
+        r'kns\.cnki\.net/.*?/article/',
+        r'.*dblp=.*',  # 包含dblp参数
+        r'.*dbta=.*'   # 包含dbta参数
+    ]
+    
+    # 编译正则表达式提高效率
+    patterns = [re.compile(pattern, re.IGNORECASE) for pattern in article_patterns]
+    
+    # 过滤链接
+    filtered_links = []
+    for link in links:
+        # 跳过明显的非文章链接
+        if any(x in link.lower() for x in [
+            'index.html', 'help.cnki.net', 'service.cnki.net', 
+            'piccache.cnki.net', 'login', 'register', 'my.cnki', 
+            'homepage', 'download.aspx', 'member.cnki'
+        ]):
+            continue
+            
+        # 检查是否匹配任何文章模式
+        is_article = False
+        for pattern in patterns:
+            if pattern.search(link):
+                is_article = True
+                break
+                
+        if is_article:
+            filtered_links.append(link)
+    
+    # 确保链接唯一
+    return list(set(filtered_links))
+
+# 独立测试函数
+async def test_extract_links(page):
+    """
+    测试链接提取功能
+    
+    Args:
+        page: Playwright页面对象
+        
+    Returns:
+        Dict: 测试结果
+    """
+    try:
+        links = await extract_links_from_page(page)
+        return {
+            "success": True,
+            "links": links,
+            "count": len(links)
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "message": "提取链接测试失败"
+        }
+
+# 如果直接执行此脚本
+if __name__ == "__main__":
+    print("链接提取模块 - 必须通过其他模块调用") 

src/ifverify.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+验证检测模块（IfVerify Module）
+
+这个模块用于检测页面是否需要人工验证（如CAPTCHA、验证码等）。
+可以被工作者模块和其他需要验证检测的模块引用。
+
+主要职责:
+1. 分析页面内容，检测可能的验证元素
+2. 辅助交互自动化流程中的人工验证步骤
+"""
+
+import logging
+import traceback
+from typing import Dict, Any
+
+# 获取logger
+logger = logging.getLogger("cnks.ifverify")
+
+async def check_verification_needed(page) -> bool:
+    """
+    检查页面是否需要人工验证
+    
+    Args:
+        page: Playwright页面对象
+        
+    Returns:
+        bool: 是否需要人工验证
+    """
+    try:
+        # 检查是否存在验证相关元素
+        verification_elements = [
+            # 验证码图片
+            'img[src*="captcha"]',
+            'img[src*="verify"]',
+            # 验证码输入框
+            'input[name*="captcha"]',
+            'input[placeholder*="验证码"]',
+            # 验证提示文本
+            'div:has-text("请输入验证码")',
+            'div:has-text("安全验证")',
+            'div:has-text("请完成验证")'
+        ]
+        
+        for selector in verification_elements:
+            element = await page.query_selector(selector)
+            if element:
+                logger.info(f"检测到验证元素: {selector}")
+                return True
+            
+        # 检查页面标题或URL是否包含验证相关关键词
+        title = await page.title()
+        url = page.url
+        verification_keywords = ["verification", "verify", "captcha", "验证", "安全检查"]
+        
+        for keyword in verification_keywords:
+            if keyword.lower() in title.lower() or keyword.lower() in url.lower():
+                logger.info(f"页面标题或URL包含验证关键词: {keyword}")
+                return True
+        
+        logger.info("未检测到需要人工验证的元素")
+        return False
+        
+    except Exception as e:
+        logger.warning(f"检查验证页面时出错: {str(e)}")
+        logger.warning(traceback.format_exc())
+        # 如果出错，保险起见认为需要验证
+        return True
+
+async def handle_verification(page, wait_time: int = 10000) -> bool:
+    """
+    处理可能的人工验证需求
+    
+    Args:
+        page: Playwright页面对象
+        wait_time: 等待人工验证的时间（毫秒）
+        
+    Returns:
+        bool: 是否成功处理验证
+    """
+    try:
+        # 检查是否需要验证
+        needs_verification = await check_verification_needed(page)
+        
+        if needs_verification:
+            logger.info(f"检测到需要人工验证，等待{wait_time/1000}秒钟...")
+            # 等待指定时间让用户进行验证
+            await page.wait_for_timeout(wait_time)
+            
+            # 再次检查是否仍需验证
+            still_needs_verification = await check_verification_needed(page)
+            if still_needs_verification:
+                logger.warning("验证可能尚未完成，但等待时间已到")
+                return False
+            else:
+                logger.info("验证已完成，继续执行")
+                return True
+        else:
+            logger.info("无需人工验证")
+            return True
+            
+    except Exception as e:
+        logger.error(f"处理验证过程中出错: {str(e)}")
+        logger.error(traceback.format_exc())
+        return False
+
+def test_verification_selectors() -> Dict[str, Any]:
+    """
+    返回用于验证检测的元素选择器列表，
+    可用于测试或扩展验证检测能力
+    
+    Returns:
+        Dict: 包含各类验证元素选择器的字典
+    """
+    return {
+        "image_selectors": [
+            'img[src*="captcha"]',
+            'img[src*="verify"]'
+        ],
+        "input_selectors": [
+            'input[name*="captcha"]',
+            'input[placeholder*="验证码"]'
+        ],
+        "text_selectors": [
+            'div:has-text("请输入验证码")',
+            'div:has-text("安全验证")',
+            'div:has-text("请完成验证")'
+        ],
+        "verification_keywords": [
+            "verification", "verify", "captcha", "验证", "安全检查"
+        ]
+    }