chat2llms 0.1.0__tar.gz

chat2llms-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+# LICENSE
+MIT License
+
+Copyright (c) 2025 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chat2llms-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: chat2llms
+Version: 0.1.0
+Summary: A framework for comparing responses from different large language models.
+Home-page: https://github.com/goldollarch/chat2llms
+Author: scitao
+Author-email: goldollarch@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# chat2llms
+
+A Python library to compare responses from different large language models (e.g., DeepSeek, Gemini, OpenAI, Grok).
+
+[![PyPI version](https://badge.fury.io/py/chat2llms.svg)](https://badge.fury.io/py/chat2llms)
+[![Documentation Status](https://readthedocs.org/projects/chat2llms/badge/?version=latest)](https://chat2llms.readthedocs.io/en/latest/?badge=latest)
+
+## Installation
+
+```bash
+pip install chat2llms
+

chat2llms-0.1.0/README.md

@@ -0,0 +1,12 @@
+# chat2llms
+
+A Python library to compare responses from different large language models (e.g., DeepSeek, Gemini, OpenAI, Grok).
+
+[![PyPI version](https://badge.fury.io/py/chat2llms.svg)](https://badge.fury.io/py/chat2llms)
+[![Documentation Status](https://readthedocs.org/projects/chat2llms/badge/?version=latest)](https://chat2llms.readthedocs.io/en/latest/?badge=latest)
+
+## Installation
+
+```bash
+pip install chat2llms
+

chat2llms-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chat2llms-0.1.0/setup.py

@@ -0,0 +1,57 @@
+import os
+from setuptools import setup, find_packages
+
+# Utility function to read the README file.
+# Used for the long_description.  It's nice, because now 1) we have a top level
+# README file and 2) it's easier to type in the README file than to put a raw
+# string in below ...
+def read(fname):
+    return open(os.path.join(os.path.dirname(__file__), fname), encoding='utf-8').read()
+
+setup(
+    name='chat2llms', # 包的名称
+    version='0.1.0', # 包的版本号 - 发布新版本时需要更新
+    author='scitao', # 作者姓名
+    author_email='goldollarch@gmail.com', # 作者邮箱
+    description='A framework for comparing responses from different large language models.', # 包的简短描述
+    long_description=read('README.md'), # 包的详细描述，从 README.md 读取
+    long_description_content_type='text/markdown', # 详细描述的格式
+    url='https://github.com/goldollarch/chat2llms', # 项目的主页或其他相关 URL
+    packages=find_packages(where='src'), # 查找 src 目录下的所有包
+    package_dir={'': 'src'}, # 指定包的根目录在 src 下
+    install_requires=[ # 项目运行时依赖的第三方库
+        'requests',
+        # 根据您的项目实际需要添加其他库
+        # 例如，如果您需要特定的 LLM 客户端，可能需要它们的 SDK：
+        # 'openai>=1.0.0',
+        # 'google-generativeai>=0.5.0',
+        # 'deepseek>=1.0.0', # 假设有这样的库
+    ],
+    classifiers=[ # 包的分类信息，对用户搜索和理解包很有帮助
+        'Development Status :: 3 - Alpha', # 开发状态
+        'Intended Audience :: Developers', # 目标受众
+        'License :: OSI Approved :: MIT License', # 许可证信息 (请根据您的实际许可证修改)
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Operating System :: OS Independent',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Text Processing :: Linguistic',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    python_requires='>=3.7', # 要求的最低 Python 版本
+    entry_points={ # 定义命令行入口点 (如果您有命令行工具)
+        'console_scripts': [
+            'chat2llms=chat2llms.cli.cli_click:main' # 示例，如果您的 CLI 入口在这里
+        ]
+    },
+    # 如果您的包包含非代码文件 (如数据文件)，可能需要 package_data 或 include_package_data
+    # include_package_data=True,
+    # package_data={
+    #     'chat2llms': ['data/*.json'], # 示例：包含 chat2llms 包内的 data 目录下的 json 文件
+    # },
+)

chat2llms-0.1.0/src/chat2llms/__init__.py

@@ -0,0 +1,7 @@
+# src/chat2llms/__init__.py
+__version__ = '0.1.0'
+
+from .cli.cli_click import main
+from .base_client import BaseClient, logger, load_config
+from .model_response import ModelResponse, OpenAIResponse, GeminiResponse
+from .analyzer import AnswerComparator, AnswerAnalyzer, MultiAnswerAnalyzer

chat2llms-0.1.0/src/chat2llms/analyzer.py

@@ -0,0 +1,271 @@
+import os
+import re
+import time
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import spacy
+import difflib
+from difflib import SequenceMatcher
+
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.feature_extraction.text import TfidfVectorizer
+# from sentence_transformers import SentenceTransformer, util
+
+from .model_response import ModelResponse, OpenAIResponse, GeminiResponse
+
+##################################
+
+@dataclass
+class ModelAnswer:
+    """模型响应数据结构"""
+
+    model_name: str
+    answer: str  # answer=response.text
+    latency: float  # latency=time.time() - start
+    tokens: int  # tokens=len(response.text.split())
+    error: Optional[str] = None
+
+class AnswerComparator:
+    """Class to compare responses from LLMs for the same question.
+
+    Args:
+        list[ModelResponse]: The LLM responses.
+
+    """
+    
+    def __init__(self, responses: List[ModelResponse], question: str = None):
+
+        self.model_names = [r.get_model_name() for r in responses]
+        self.responses = responses
+        self.question = question
+
+        self.vectorizer = TfidfVectorizer(stop_words="english")
+
+        # # 初始化模型（用于相似度计算）
+        # self.sim_model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
+
+    def get_answers(self, question: str) -> List[ModelAnswer]:
+        """获取多模型响应"""
+        answers = [self.get_model_answer(question, r) for r in self.responses]
+        return answers
+
+    def get_model_answer(self, question: str, response: ModelResponse):
+        """获取模型响应"""
+        model_name = response.get_model_name()
+        try:
+            start = time.time()
+            answer = response.get_response(question)
+            return ModelAnswer(
+                model_name=model_name,
+                answer=answer,
+                latency=time.time() - start,
+                tokens=len(answer.split()),
+            )
+        except Exception as e:
+            return ModelAnswer(model_name, "", 0, 0, str(e))
+
+    def analyze_answers(self, responses: List[ModelAnswer]) -> Dict:
+        """执行对比分析"""
+        valid_responses = [r for r in responses if not r.error]
+
+        # 语义相似度分析
+        answers = [r.answer for r in valid_responses]
+        tfidf = self.vectorizer.fit_transform(answers)
+        similarity = cosine_similarity(tfidf)
+
+        # 关键差异提取
+        differences = self._extract_differences(answers)
+
+        return {
+            "similarity_matrix": similarity,
+            "performance": {
+                r.model_name: {"latency": r.latency, "tokens": r.tokens}
+                for r in valid_responses
+            },
+            "key_differences": differences,
+            "errors": [r for r in responses if r.error],
+        }
+
+    def _extract_differences(self, answers: List[str]) -> List[str]:
+        """提取关键差异点"""
+        noun_phrases = []
+        for ans in answers:
+            phrases = re.findall(
+                r"\b[A-Z][a-z]+\s[A-Z][a-z]+\b|\b\w+ion\b|\b\w+ment\b", ans
+            )
+            noun_phrases.extend(phrases)
+
+        unique_phrases = list(set(noun_phrases))
+        return [
+            phrase
+            for phrase in unique_phrases
+            if sum(1 for ans in answers if phrase in ans) < len(answers)
+        ][:5]
+
+    def generate_report(self, analysis: Dict, question: str) -> str:
+        """生成分析报告"""
+        report = [
+            f"# 问题分析报告\n**问题**: {question}\n",
+            "## 性能对比",
+            *self._format_performance(analysis["performance"]),
+            "\n## 语义相似度",
+            self._format_matrix(analysis["similarity_matrix"]),
+            "\n## 关键差异点",
+            *[f"- {diff}" for diff in analysis["key_differences"]],
+            "\n## 错误日志",
+            *self._format_errors(analysis["errors"]),
+        ]
+        return "\n".join(report)
+
+    def _format_performance(self, perf: Dict) -> List[str]:
+        return [
+            f"### {model}\n"
+            f"- 响应时间: {data['latency']:.2f}s\n"
+            f"- Token使用量: {data['tokens']}"
+            for model, data in perf.items()
+        ]
+
+    def _format_matrix(self, matrix: np.ndarray) -> str:
+        return (
+            "```\n" + "\n".join(["\t".join(map(str, row)) for row in matrix]) + "\n```"
+        )
+
+    def _format_errors(self, errors: List[ModelAnswer]) -> List[str]:
+        return [f"- {err.model_name}: {err.error}" for err in errors if err.error]
+
+
+# #############################
+
+class AnswerAnalyzer:
+    """Class to compare responses from two LLMs for the same prompt.
+
+    Args:
+        response1 (ModelResponse): The first LLM response.
+        response2 (ModelResponse): The second LLM response.
+
+    Attributes:
+        response1 (ModelResponse): The first response object.
+        response2 (ModelResponse): The second response object.
+        nlp (spacy.language.Language): SpaCy NLP model (optional).
+    """
+
+    def __init__(self, response1: ModelResponse, response2: ModelResponse, question: str = None):
+
+        self.question = question
+        self.response1 = response1
+        self.response2 = response2
+
+        self.nlp: Optional[spacy.language.Language] = None
+
+        try:
+            self.nlp = spacy.load("en_core_web_sm")
+        except ImportError:
+            print("SpaCy not installed or model not found. Install with: pip install spacy && python -m spacy download en_core_web_sm")
+
+    def compute_similarity(self) -> float:
+        """Compute similarity between two responses using SequenceMatcher.
+
+        Returns:
+            float: Similarity score etween 0.0 and 1.0.
+        """
+        question = self.question
+        text1 = self.response1.get_response(question)
+        text2 = self.response2.get_response(question)
+        
+        matcher = SequenceMatcher(None, text1, text2)
+        return matcher.ratio()
+
+    def compute_semantic_similarity(self) -> float:
+        """Compute semantic similarity using Spacy.
+
+        Returns:
+            float: Semantic similarity score between 0.0 and 1.0, or -1.0 if SpaCy is unavailable.
+        """
+        if self.nlp is None:
+            return -1.0
+        
+        question = self.question
+        text1 = self.response1.get_response(question)
+        text2 = self.response2.get_response(question)
+        
+        doc1 = self.nlp(text1)
+        doc2 = self.nlp(text2)
+        return doc1.similarity(doc2)
+
+    def highlight_differences(self) -> str:
+        """Highlight differences between two responses.
+
+        Returns:
+            str: A formatted string showing both responses.
+        """
+
+        question = self.question
+        text1 = self.response1.get_response(question)
+        text2 = self.response2.get_response(question)
+        
+        return f"Response 1 ({self.response1.get_model_name()}):\n{text1}\n\nResponse 2 ({self.response2.get_model_name()}):\n{text2}"
+
+    def save_comparison_to_csv(self, filename: str):
+        import csv
+        question = self.question
+        with open(filename, 'w', newline='') as f:
+            writer = csv.writer(f)
+            writer.writerow(['Prompt', 'Model1', 'Response1', 'Model2', 'Response2', 'Text Similarity', 'Semantic Similarity'])
+            writer.writerow([
+                question,
+                self.response1.get_model_name(),
+                self.response1.get_response(question),
+                self.response2.get_model_name(),
+                self.response2.get_response(question),
+                self.compute_similarity(),
+                self.compute_semantic_similarity()
+            ])
+
+    def plot_similarity(self):
+        similarities = [self.compute_similarity(), self.compute_semantic_similarity()]
+        labels = ['Text Similarity', 'Semantic Similarity']
+        plt.bar(labels, similarities)
+        plt.ylim(0, 1)
+        plt.title('Response Similarity Comparison')
+        plt.savefig('similarity_plot.png')
+        plt.show()
+
+class MultiAnswerAnalyzer:
+    """Class to compare responses from LLMs for the same prompt.
+    
+    Args:
+        list[ModelResponse]: The LLM responses.
+
+    Attributes:
+        list[ModelResponse]: many LLMs, not only two.
+    
+    Methods:
+        compare_all(): compare responses.
+        
+    """
+
+    def __init__(self, responses: list[ModelResponse], question: str = None):
+        """Initialize MultiAnswerAnalyzer.
+        
+        Args:
+            list[ModelResponse]: The LLM responses.
+
+        Attributes:
+            list[ModelResponse]: many LLMs, not only two.
+        
+        """
+
+        self.question = question
+        self.responses = responses
+        
+
+    def compare_all(self):
+        for i in range(len(self.responses)):
+            for j in range(i + 1, len(self.responses)):
+                analyzer = AnswerAnalyzer(self.responses[i], self.responses[j], self.question)
+                print(f"Comparing {self.responses[i].get_model_name()} vs {self.responses[j].get_model_name()}")
+                print(analyzer.highlight_differences())

chat2llms-0.1.0/src/chat2llms/base_client.py

@@ -0,0 +1,84 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Tuple
+
+import requests
+import logging
+import yaml
+import os
+
+# 配置日志记录
+logging.basicConfig(
+    filename="chat_history.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# 加载配置文件
+def load_config(config_path: str = "config.yaml") -> Dict:
+    """加载配置文件"""
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f)
+    except (FileNotFoundError, yaml.YAMLError) as e:
+        logger.error(f"配置文件加载失败: {str(e)}")
+        raise
+
+# == 基础类定义 ==
+class BaseClient(ABC):
+    """Base class for large language model clients.
+
+    Args:
+        provider (str): The provider of the LLM model.
+        config (Dict): The model parameters of the LLM model.
+
+    Attributes:
+        provider (str): The provider.
+        config (Dict): Other parameters.        
+    """
+
+    def __init__(self, provider: str, config: Dict = None):
+        """初始化客户端配置"""
+
+        providers = {"gemini", "openai", "grok", "deepseek"}
+
+        if provider not in providers:
+            print("Unknown provider, Using DeepSeek instead")
+            self.provider = "deepseek" 
+        else:
+            self.provider = provider
+
+        config = load_config()
+        self.timeout = config[self.provider].get("timeout", 30)
+        self.max_retries = config[self.provider].get("max_retries", 3)
+        self.max_history = config[self.provider].get("max_history", 10)  # 保留最近10轮对话
+               
+        if self.provider == "openai":
+            self.api_key = config[self.provider].get("api_key", os.getenv("OPENAI_API_KEY")) 
+            self.base_url = config[self.provider].get("base_url", "https://api.openai.com/v1")
+            self.model_name = config[self.provider].get("model", "gpt-4")
+
+        elif self.provider == "gemini":
+            self.api_key = config[self.provider].get("api_key", os.getenv("GEMINI_API_KEY")) 
+            self.base_url = config[self.provider].get(
+                "base_url", "https://generativelanguage.googleapis.com/v1beta"
+            )
+            self.model_name = config[self.provider].get("model", "gemini-1.5-pro")
+
+        elif self.provider == "grok":
+            self.api_key = config[self.provider].get("api_key", os.getenv("XAI_API_KEY")) 
+            self.base_url = config[self.provider].get("base_url", "https://api.x.ai/v1")
+            self.model_name = config[self.provider].get("model", "grok-2-latest")
+
+        else:
+            self.api_key = config[self.provider].get("api_key", os.getenv("DEEPSEEK_API_KEY"))
+            self.base_url = config[self.provider].get("base_url", "https://api.deepseek.com")
+            self.model_name = config[self.provider].get("model", "deepseek-chat")
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        if self.provider == "gemini":
+            self.headers.pop("Authorization")

chat2llms-0.1.0/src/chat2llms/model_response.py

@@ -0,0 +1,295 @@
+import os
+import datetime
+from markdown import markdown
+from typing import List, Dict, Tuple
+import requests
+import json
+
+from abc import ABC, abstractmethod
+
+from .base_client import BaseClient, logger
+
+import openai
+import google.generativeai as genai
+
+# === 响应处理类 ===
+class ModelResponse(BaseClient):
+    """Class to handle responses from a specific LLM for a given prompt.
+
+    Args:
+        client (BaseClient): The LLM client instance.
+        prompt (str): The input prompt for the LLM.
+
+    Attributes:
+        client (BaseClient): The LLM client.
+        prompt (str): The input prompt.
+    """
+
+    def __init__(self, client: BaseClient, prompt: str = None):
+        self.client = client
+        self.prompt = prompt
+        self._response = None
+        # self.response = None
+
+        self.latency = 0  # latency=time.time() - start
+        self.tokens = 0  # tokens=len(response.text.split())
+        self.error = None
+
+        self.history: List[Dict] = []  # 存储完整对话历史
+        self.max_history = 20  # 最大保留历史轮次
+
+    """无历史响应"""
+
+    @abstractmethod
+    def call_api(self, prompt):
+        """调用模型API的抽象方法"""
+        raise NotImplementedError()
+
+    def get_model_name(self):
+        """获取模型响应"""
+        return self.client.model_name
+
+    def get_prompt_str(self):
+        """获取提示词"""
+        return self.prompt
+
+    def api_response(self, prompt: str):
+        """获取模型响应"""
+        if not self._response:
+            try:
+                self.prompt = prompt
+                self._response = self.call_api(prompt)
+            except Exception as e:
+                self._response = f"Error: {str(e)}"
+        return self._response
+
+    """历史响应"""
+    @abstractmethod
+    def get_response(
+        self,
+        prompt: str,
+        history: List[Dict] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4000,
+    ) -> str:
+        """同步生成回复"""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_response_history(
+        self, prompt: str, history: List[Dict] = None
+    ) -> Tuple[str, List[Dict]]:
+        """发送消息并返回响应和更新后的历史"""
+        pass
+
+    def _build_messages(self, prompt: str, history: List[Dict]) -> List[Dict]:
+        """构造对话历史（可被子类重写）"""
+        messages = history.copy()
+        messages.append({"role": "user", "content": prompt})
+        return messages
+
+
+class OpenAIResponse(ModelResponse):
+    """OpenAI API 客户端实现"""
+
+    def call_api(self, prompt):
+        client = openai.OpenAI(
+            api_key=self.client.api_key, base_url=self.client.base_url
+        )
+        response = client.chat.completions.create(
+            model=self.client.model_name, messages=[{"role": "user", "content": prompt}]
+        )
+        return response.choices[0].message.content
+
+    """直接调用 OpenAI API 底层接口"""
+
+    def get_response(self, prompt, history=None, temperature=0.7, max_tokens=4000):
+        if not self._response:
+            try:
+                self.prompt = prompt
+                messages = self._build_messages(prompt, history or [])
+                response = requests.post(
+                    f"{self.client.base_url}/chat/completions",
+                    headers=self.client.headers,
+                    json={
+                        "model": self.client.model_name,
+                        "messages": messages,
+                        "temperature": temperature,
+                        "max_tokens": max_tokens,
+                    },
+                )
+                result = response.json()
+                self._response = result["choices"][0]["message"]["content"]
+            except Exception as e:
+                self._response = f"Error: {str(e)}"
+        return self._response
+
+    def get_response_history(
+        self, message: str, history: List[Dict] = []
+    ) -> Tuple[str, List[Dict]]:
+
+        new_history = self._update_history(history, message, role="user")
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.client.api_key}",
+        }
+
+        payload = {
+            "model": self.client.model_name,
+            "messages": new_history[-self.client.max_history * 2 :],  # 保留最近的对话
+        }
+
+        for attempt in range(self.client.max_retries):
+            try:
+                response = requests.post(
+                    f"{self.client.base_url}/chat/completions",
+                    headers=headers,
+                    json=payload,
+                    timeout=self.client.timeout,
+                )
+                response.raise_for_status()
+                response_data = response.json()
+                assistant_message = response_data["choices"][0]["message"][
+                    "content"
+                ].strip()
+
+                updated_history = self._update_history(
+                    new_history, assistant_message, role="assistant"
+                )
+                return (
+                    assistant_message,
+                    updated_history[-self.client.max_history * 2 :],
+                )
+
+            except requests.exceptions.RequestException as e:
+                logger.warning(
+                    f"API请求失败，尝试 {attempt + 1}/{self.client.max_retries}: {str(e)}"
+                )
+                if attempt == self.client.max_retries - 1:
+                    raise RuntimeError("API请求超过最大重试次数") from e
+
+            except (KeyError, IndexError, TypeError) as e:
+                logger.error(f"响应解析错误: {str(e)}")
+                raise RuntimeError("服务器返回了无效的响应格式") from e
+
+        return "", history
+
+    def _build_messages(self, prompt: str, history: List[Dict]) -> List[Dict]:
+        return [*history, {"role": "user", "content": prompt}]
+
+    def _update_history(
+        self, history: List[Dict], content: str, role: str
+    ) -> List[Dict]:
+        """更新对话历史"""
+        return history + [{"role": role, "content": content}]
+
+
+class GeminiResponse(ModelResponse):
+
+    def init_google_genai(self):
+        genai.configure(api_key=self.client.api_key)
+        self.model = genai.GenerativeModel(self.client.model_name)
+
+    """Gemini API 客户端实现"""
+
+    def call_api(self, prompt):
+        self.init_google_genai()
+        response = self.model.generate_content(prompt)
+        return response.text
+
+    # 使用 request 直接调用 Gemini API 底层接口。
+    # 底层接口：​由 Google 提供的 HTTP REST 或 gRPC 端点，如
+    # https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent
+    # 开发者可以直接通过 HTTP 请求调用，无需依赖特定语言的库。适合需要灵活性的高级用户或跨语言集成。
+
+    def get_response(self, prompt, history=None, temperature=0.7, max_tokens=4000):
+        if not self._response:
+            try:
+                self.prompt = prompt
+                messages = self._build_messages(prompt, history or [])
+                response = requests.post(
+                    f"{self.client.base_url}/models/{self.client.model_name}:generateContent?key={self.client.api_key}",
+                    headers=self.client.headers,
+                    json={
+                        "contents": messages,
+                        "generationConfig": {
+                            "temperature": temperature,
+                            "maxOutputTokens": max_tokens,
+                        },
+                    },
+                )
+                result = response.json()
+                self._response = result["candidates"][0]["content"]["parts"][0]["text"]
+            except Exception as e:
+                self._response = f"Error: {str(e)}"
+        return self._response
+
+    def get_response_history(self, prompt: str, history=None) -> Tuple[str, List[Dict]]:
+        """执行带历史管理的对话"""
+        try:
+            # 构造请求头
+            headers = {
+                "Content-Type": "application/json",
+                "x-goog-api-key": self.client.api_key,
+            }
+
+            # 添加当前对话到历史
+            self.history.append({"type": "chat", "role": "user", "content": prompt})
+
+            # 发送API请求
+            response = requests.post(
+                f"{self.client.base_url}/models/{self.client.model_name}:generateContent",
+                headers=headers,
+                json=self._build_payload(prompt),
+            )
+            response.raise_for_status()
+
+            # 解析响应
+            ai_response = self._parse_response(response.json())
+
+            # 记录AI响应历史
+            self.history.append(
+                {"type": "chat", "role": "model", "content": ai_response}
+            )
+
+            return ai_response, self.history
+
+        except requests.exceptions.RequestException as e:
+            # 网络错误处理
+            self.history.append({"type": "system", "content": f"网络错误: {str(e)}"})
+            return f"API请求失败: {str(e)}"
+
+        except json.JSONDecodeError:
+            # JSON解析错误
+            return "响应解析失败"
+
+    def _build_messages(self, prompt, history):
+        # Gemini的messages结构不同
+        return [
+            {"parts": [{"text": msg["content"]}], "role": msg["role"].upper()}
+            for msg in super()._build_messages(prompt, history)
+        ]
+
+    def _build_payload(self, prompt: str) -> Dict:
+        """构造包含聊天历史的请求体"""
+        parts = [{"text": prompt}]
+
+        # 添加历史上下文（排除系统指令）
+        context = [
+            {"role": entry["role"], "parts": [{"text": entry["content"]}]}
+            for entry in self.history[-self.max_history :]
+            if entry["type"] == "chat"
+        ]
+
+        return {
+            "contents": context + [{"role": "user", "parts": parts}],
+            "generationConfig": {"temperature": 0.9, "maxOutputTokens": 4000},
+        }
+
+    def _parse_response(self, response: Dict) -> str:
+        """解析API响应并提取文本内容"""
+        try:
+            return response["candidates"][0]["content"]["parts"][0]["text"]
+        except (KeyError, IndexError) as e:
+            raise ValueError(f"无效的API响应结构: {str(e)}")

chat2llms-0.1.0/src/chat2llms/output_files.py

@@ -0,0 +1,239 @@
+import datetime
+from typing import Dict, List
+
+from markdown import markdown
+
+import os
+import subprocess
+import re
+
+# from difflib import Differ
+
+SAVE_PATH = "docs/refers/Chats"  # 保存目录
+
+class WriteMarkDown:
+    def __init__(self, filename: str):
+
+        self._init_md_structure(filename)
+
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = f"{SAVE_PATH}/{filename}_{timestamp}.md"
+        self.output_path = output_path
+
+    def _init_md_structure(self, filename: str):
+        """初始化Markdown文档结构"""
+        self.md_content = [
+            f"# {filename}\n",
+            f"**生成时间**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n",
+        ]
+
+    def add_comparison_table(
+        self, metrics: Dict[str, List[float]], model_names: List[str]
+    ):
+        """
+        添加指标对比表格
+        :param metrics: 指标字典 {指标名称: [模型1值, 模型2值...]}
+        :param model_names: 模型名称列表
+        """
+        # 生成表头
+        header = "| 指标 " + " ".join([f"| {name} " for name in model_names]) + "|"
+        separator = "|-----" + " ".join(["|----" for _ in model_names]) + "|"
+
+        # 生成数据行
+        rows = []
+        for metric, values in metrics.items():
+            row = f"| ​**{metric}** " + " ".join([f"| {v} " for v in values]) + "|"
+            rows.append(row)
+
+        # 组装表格
+        table = [header, separator] + rows
+        self.md_content.extend(["\n## 性能对比\n"] + table)
+
+    def add_conclusion(self, conclusions: List[str], highlight: str = None):
+        """
+        添加分析结论
+        :param conclusions: 结论条目列表
+        :param highlight: 需要高亮显示的关键结论
+        """
+        conclusion_section = ["\n## 最终结论\n"]
+        for item in conclusions:
+            conclusion_section.append(f"- {item}")
+
+        if highlight:
+            conclusion_section.append(f"\n**关键结论**: {highlight}")
+
+        self.md_content.extend(conclusion_section)
+
+    def save(self, mode: str = "w"):
+        """保存Markdown文件"""
+        with open(self.output_path, mode, encoding="utf-8") as f:
+            f.write("\n".join(self.md_content))
+
+    def add_section(self, title: str, content: str, level: int = 2):
+        """添加自定义章节"""
+        prefix = "#" * level
+        self.md_content.append(f"\n{prefix} {title}\n{content}")
+
+    def add_plot(self, plot_path: str, caption: str = ""):
+        """插入本地图片"""
+        self.md_content.append(f"\n![{caption}]({plot_path})")
+
+    def add_diff_analysis(self, text_a: str, text_b: str):
+        """文本差异对比"""
+        differ = Differ()
+        diff = list(differ.compare(text_a.split(), text_b.split()))
+        self.add_section("响应差异分析", "```diff\n" + "\n".join(diff) + "\n```")
+
+    def add_response(self, question: str, model: str, answer: str):
+        """保存对话记录到Markdown文件"""
+
+        self.add_section("用户提问", question)
+        self.add_section(f"{model}模型回复", answer)
+
+
+def convert_with_pandoc(input_path, output_path):
+    try:
+        subprocess.run(
+            [
+                "pandoc",
+                "-s",
+                input_path,
+                "-t",
+                "markdown+hard_line_breaks+pipe_tables",
+                "-o",
+                output_path,
+                "--extract-media=./images",
+            ],
+            check=True,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"转换错误: {str(e)}")
+        return False
+
+
+def docx_to_sphinx_rst(docx_path, rst_path):
+    # Step 1: 使用 Pandoc 转换基础格式
+    subprocess.run(
+        [
+            "pandoc",
+            "--extract-media=./_static",
+            "--shift-heading-level-by=1",
+            "-t",
+            "rst+auto_identifiers",
+            "-o",
+            rst_path,
+            docx_path,
+        ],
+        check=True,
+    )
+
+    # Step 2: 后处理优化
+    with open(rst_path, "r+", encoding="utf-8") as f:
+        content = f.read()
+
+        # 修复表格对齐问题
+        content = re.sub(r"(\+-+)+\+", lambda m: m.group().replace("-", "="), content)
+
+        # 转换 Word 注释为 Sphinx 警告框
+        content = re.sub(r"^\.\.\scomment::", ".. warning::", content, flags=re.M)
+
+        # 添加 docutils 特殊指令支持
+        if ".. code-block::" in content:
+            content = ".. highlight:: python\n\n" + content
+
+        f.seek(0)
+        f.write(content)
+        f.truncate()
+
+
+def md_to_rst(md_path, rst_path):
+    # Step 1: 使用 Pandoc 转换
+    subprocess.run(
+        [
+            "pandoc",
+            "-f",
+            "markdown+yaml_metadata_block",
+            "-t",
+            "rst",
+            "-o",
+            rst_path,
+            md_path,
+        ],
+        check=True,
+    )
+
+    # Step 2: 格式修正
+    with open(rst_path, "r+", encoding="utf-8") as f:
+        content = f.read()
+
+        # 修复代码块语法
+        content = re.sub(r"^\.\. code::\s*$", ".. code-block::", content, flags=re.M)
+
+        # 转换表格格式
+        content = re.sub(r"(\+-+)+\+", lambda m: m.group().replace("-", "="), content)
+
+        # 修正图片路径
+        content = re.sub(r"!$$(.*?)$$$(.*?)$", r".. image:: \2\n   :alt: \1", content)
+
+        f.seek(0)
+        f.write(content)
+        f.truncate()
+
+
+# 使用示例
+
+if __name__ == "__main__":
+    # # 初始化分析器
+    # analyzer = WriteMarkDown("comparison")
+
+    # # 添加性能对比表格
+    # metrics = {
+    #     "准确率(%)": [92.3, 89.7],
+    #     "推理速度(ms)": [15.2, 28.4],
+    #     "内存占用(GB)": [1.2, 0.8],
+    #     "F1 Score": [0.88, 0.85]
+    # }
+    # analyzer.add_comparison_table(metrics, ["GPT-4", "DeepSeek-R1"])
+
+    # # 添加结论
+    # conclusions = [
+    #     "GPT-4在精度指标上全面领先",
+    #     "DeepSeek-R1在内存效率方面表现优异",
+    #     "两者响应速度均满足实时需求"
+    # ]
+    # analyzer.add_conclusion(conclusions,
+    #                       highlight="推荐高精度场景使用GPT-4，资源受限环境选择DeepSeek-R1")
+
+    # # 添加自定义分析模块
+    # analyzer.add_section(
+    #     "错误案例分析",
+    #     "```python\n# 典型错误示例\nprint(f'1 + 1 = {1+1=}')  # DeepSeek-R1输出格式问题\n```"
+    # )
+
+    # text_a = "GPT-4在精度指标上全面领先"
+    # text_b = "DeepSeek-R1在内存指标方面表现优异"
+    # analyzer.add_diff_analysis(text_a, text_b)
+
+    # caption = "cenjoy"
+    # plot_path = "docs/source/_static/cenjoy.png"
+    # analyzer.add_plot(plot_path, caption)
+
+    # # 生成最终报告
+    # analyzer.save()
+
+    # # 文档转换使用示例
+    input_path = "xcenjoy.docx"
+    output_path = "xcenjoy.md"
+    convert_with_pandoc(input_path, output_path)
+
+    # input_path = "Letter.docx"
+    # output_path = "Letter.rst"
+    # docx_to_sphinx_rst(input_path, output_path)
+
+    # input_path = "Letter_cn.md"
+    # output_path = "Letter_cn.rst"
+    # md_to_rst(input_path, output_path)
+
+    # # rstfromdocx
+    # os.system("rstfromdocx -lurg 项目概要.docx")

chat2llms-0.1.0/src/chat2llms.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: chat2llms
+Version: 0.1.0
+Summary: A framework for comparing responses from different large language models.
+Home-page: https://github.com/goldollarch/chat2llms
+Author: scitao
+Author-email: goldollarch@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# chat2llms
+
+A Python library to compare responses from different large language models (e.g., DeepSeek, Gemini, OpenAI, Grok).
+
+[![PyPI version](https://badge.fury.io/py/chat2llms.svg)](https://badge.fury.io/py/chat2llms)
+[![Documentation Status](https://readthedocs.org/projects/chat2llms/badge/?version=latest)](https://chat2llms.readthedocs.io/en/latest/?badge=latest)
+
+## Installation
+
+```bash
+pip install chat2llms
+

chat2llms-0.1.0/src/chat2llms.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.py
+src/chat2llms/__init__.py
+src/chat2llms/analyzer.py
+src/chat2llms/base_client.py
+src/chat2llms/model_response.py
+src/chat2llms/output_files.py
+src/chat2llms/utils.py
+src/chat2llms.egg-info/PKG-INFO
+src/chat2llms.egg-info/SOURCES.txt
+src/chat2llms.egg-info/dependency_links.txt
+src/chat2llms.egg-info/entry_points.txt
+src/chat2llms.egg-info/requires.txt
+src/chat2llms.egg-info/top_level.txt
+tests/test_analyzer.py

chat2llms-0.1.0/src/chat2llms.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chat2llms-0.1.0/src/chat2llms.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chat2llms = chat2llms.cli.cli_click:main

chat2llms-0.1.0/src/chat2llms.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

chat2llms-0.1.0/src/chat2llms.egg-info/top_level.txt

@@ -0,0 +1 @@
+chat2llms

chat2llms-0.1.0/tests/test_analyzer.py

@@ -0,0 +1,35 @@
+import pytest
+
+import os, sys
+sys.path.append(os.path.join(os.path.dirname(__file__),'..') )
+
+from src.chat2llms.analyzer import AnswerAnalyzer
+from src.chat2llms.model_response import OpenAIResponse, GeminiResponse
+from src.chat2llms.base_client import BaseClient
+
+def test_semantic_similarity():
+    gemini = BaseClient("gemini")
+    deepseek = BaseClient("deepseek")
+    question = "What is 2 + 2?"
+    gemini_response = GeminiResponse(gemini)
+    deepseek_response = OpenAIResponse(deepseek)
+    analyzer = AnswerAnalyzer(gemini_response, deepseek_response, question)
+    semantic_sim = analyzer.compute_semantic_similarity()
+    assert semantic_sim >= -1.0  # -1.0 if SpaCy is unavailable
+    
+    # 使用示例
+if __name__ == "__main__":
+
+    # 初始化客户端
+    gemini = BaseClient("gemini")
+    deepseek = BaseClient("deepseek")
+
+    # 获取响应
+    question = "What is 2 + 2?"
+    gemini_response = GeminiResponse(gemini)
+    deepseek_response = OpenAIResponse(deepseek)
+    analyzer = AnswerAnalyzer(gemini_response, deepseek_response, question)
+    
+    print(f"Similarity: {analyzer.compute_similarity():.2f}")
+    print(f"semantic_sim: {analyzer.compute_semantic_similarity():.2f}")
+    print(analyzer.highlight_differences())