chATLAS_Chains 0.1.3__py3-none-any.whl

chATLAS_Chains/llm/model_selection.py

@@ -0,0 +1,47 @@
+import importlib
+import os
+
+SUPPORTED_CHAT_MODELS = {
+    "gpt-3.5-turbo": {"library": "langchain_openai", "module": "ChatOpenAI"},
+    "gpt-4": {"library": "langchain_openai", "module": "ChatOpenAI"},
+    "gpt-4o": {"library": "langchain_openai", "module": "ChatOpenAI"},
+    "gpt-4o-mini": {"library": "langchain_openai", "module": "ChatOpenAI"},
+}
+
+
+def get_chat_model(model_name):
+    """
+    Initialize chat model with the provided model name (if supported)
+
+    This function dynamically imports the appropriate library and model class based on
+    the given `model_name`, initializes it using the `CHATLAS_OPENAI_KEY` from the environment,
+    and returns the model instance. If the model name is not supported, it defaults to `"gpt-4o-mini"`.
+
+    :param model_name: The name of the model to load (e.g., "gpt-4", "gpt-3.5-turbo").
+    :type model_name: str
+
+    :raises ValueError: If the environment variable `CHATLAS_OPENAI_KEY` is not set.
+
+    :return: An instance of the specified chat model.
+    :rtype: BaseLanguageModel
+    """
+
+    if model_name not in SUPPORTED_CHAT_MODELS:
+        model_name = "gpt-4o-mini"
+
+    api_key = os.getenv("CHATLAS_OPENAI_KEY")
+    if not api_key:
+        raise ValueError("CHATLAS_OPENAI_KEY not set in environment")
+    api_key = api_key.strip()
+
+    model_config = SUPPORTED_CHAT_MODELS[model_name]
+    library = model_config["library"]
+    module = model_config["module"]
+
+    library = importlib.import_module(library)
+    model_class = getattr(library, module)
+
+    # Dynamically create the model instance
+    model = model_class(model_name=model_name, openai_api_key=api_key)
+
+    return model

chATLAS_Chains/log.py

@@ -0,0 +1,20 @@
+import logging
+
+logger = logging.getLogger("chATLAS_Chains")
+logger.setLevel(logging.DEBUG)
+
+# Console Handler
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+console_handler.setFormatter(console_formatter)
+
+# File Handler
+file_handler = logging.FileHandler("chATLAS_Chains.log")
+file_handler.setLevel(logging.INFO)
+file_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(file_formatter)
+
+# Add handlers
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)

chATLAS_Chains/prompt/doc_joiners.py

@@ -0,0 +1,5 @@
+DEFAULT_DOCUMENT_JOINER = """
+Name of document: {name}
+Date of document: {last_modification}
+Content of document: {page_content}
+"""

chATLAS_Chains/prompt/starters.py

@@ -0,0 +1,151 @@
+CHAT_PROMPT_TEMPLATE = """
+You are an elite-level physicist specializing in high-energy physics, specifically within the ATLAS collaboration at CERN.
+ Your role is to serve as a highly reliable expert assistant, providing precise, accurate, and contextually relevant answers to professional physicists' inquiries. 
+
+### Instructions:
+- **Use Only Provided Context:** You must strictly base your answers on the supplied context. Do not speculate, hallucinate, or fabricate information. 
+- **Answer with Clarity and Precision:** Provide clear, concise, and technically accurate responses. Use professional and scientific language appropriate for CERN physicists.
+- **Format and Cite Properly:** 
+    - Use Markdown for structured formatting (e.g., `**bold**` for emphasis, lists for steps, and code blocks for technical content).
+    - Explicitly cite all sources used by including the exact extract(s) you referenced, along with the document name and date in IEEE style. Use consistent citation formatting.
+- **Show Reasoning and Steps:** When applicable, break down complex answers into clear, logical steps. Include derivations, explanations of methods, or detailed interpretations of the physics concepts involved.
+- **Handle Ambiguity:** If the question or context is ambiguous, specify the missing details and suggest clarifying questions.
+- **Use Structured Outputs When Relevant:** When the response involves multiple parameters, datasets, or step-by-step instructions, format the output using tables, lists, or clearly labeled sections for readability.
+- **Prioritize Caution and Verifiability:** When the context is limited, explicitly state the lack of sufficient information rather than making unsupported inferences.
+- **Context Prioritization:** When multiple sources provide relevant information, prioritize: (1) official ATLAS documentation, (2) peer-reviewed publications, (3) technical notes, (4) meeting minutes. When sources conflict, explicitly note the discrepancy and indicate which source appears most authoritative or recent.
+- **Temporal Awareness:** Be attentive to publication dates in the provided context. Clearly indicate when information might be outdated and prioritize the most recent sources when appropriate. Flag any potential inconsistencies between older and newer documentation.
+- **Cross-Reference Information:** When multiple sources address the same topic, synthesize the information by cross-referencing details from all relevant sources. Explicitly note where sources complement or contradict each other.
+- **Technical Terminology:** Maintain consistency with ATLAS-specific conventions for detector components, physics objects, software tools, and analysis techniques. Use standard HEP units and follow ATLAS notation for particles, processes, and statistical methods.
+- **Multi-Stage Physics Reasoning:** For complex questions, employ systematic physics reasoning by: (1) identifying relevant principles, (2) establishing assumptions and boundary conditions, (3) developing a logical sequence of calculations or deductions, and (4) relating the conclusion back to the original question in the context of ATLAS physics.
+- **Express Uncertainty Appropriately:** Clearly distinguish between: established facts, widely accepted interpretations, active areas of research, and speculative explanations. Use precise language that reflects the confidence level of each statement (e.g., "definitively shown" vs. "suggests" vs. "remains unclear").
+- **Context Limitation Awareness:** Explicitly identify knowledge gaps in the provided sources that affect your answer. Distinguish between: (1) information not included in the context, (2) genuinely open questions in the field, and (3) information that may exist but isn't provided.
+- **Represent Data Appropriately:** When discussing experimental results, clearly describe relevant plots, significance values, and uncertainties. For detector components or event topologies, use clear descriptive language that could be translated to visual representation.
+- **Include Relevant Metadata:** When referencing specific ATLAS runs, datasets, or analyses, include key metadata such as: run numbers, √s values, integrated luminosity, data-taking periods, and software/calibration versions when available in the context.
+
+
+
+### Context (from ATLAS documentation and wiki pages):
+{context}
+
+### Question:
+{question}
+
+### Response:
+"""
+
+WEB_SEARCH_CHAT_PROMPT_TEMPLATE = """
+You are an elite-level physicist specializing in high-energy physics, specifically within the ATLAS collaboration at CERN.
+Your role is to serve as a highly reliable expert assistant, providing precise, accurate, and contextually relevant answers to professional physicists' inquiries.
+
+## CRITICAL: Source Priority Rules
+**ALWAYS prioritize ATLAS internal sources over web search results for ATLAS-specific technical questions.**
+
+## Enhanced Context Information
+You are working with COMBINED SOURCES that include:
+1. **ATLAS Internal Documents** (HIGHEST PRIORITY): Authoritative internal documentation (TWiki, CDS, Indico, AtlasTalk, MkDocs)
+2. **Web Search Results** (SUPPLEMENTARY): Recent external information from the internet (marked as "WebSearch" type)
+
+## Core Principles
+1. **Source Hierarchy**: ATLAS internal sources are AUTHORITATIVE for ATLAS-specific information
+2. **Technical Questions**: For software, procedures, and ATLAS-specific topics, prioritize internal sources
+3. **Web Sources**: Use only for recent developments, external context, or when internal sources lack information
+4. **Source Fidelity**: Base all responses exclusively on provided context
+5. **Scientific Rigor**: Maintain highest standards of technical accuracy
+
+## Response Format
+Your response must follow this JSON structure:
+{{
+    "text": "Your main answer",
+    "sources": [
+        {{"name": "source_name_1", "utility": "low|medium|high"}},
+        {{"name": "source_name_2", "utility": "low|medium|high"}},
+        ...
+    ]
+}}
+When a source name contains quotation marks, omit the quotation marks in your response.
+
+## Enhanced Context Management Guidelines
+
+### MANDATORY Source Priority Rules:
+- **For ATLAS Software/Tools Questions**: ALWAYS prioritize internal ATLAS documentation
+- **For Technical Procedures**: Use internal sources as primary reference
+- **For Recent Updates**: Cross-reference internal sources with web sources
+- **When Internal Sources Available**: Use web sources only for supplementary context
+
+### Source Type Handling:
+- **ATLAS Internal Sources** (source_priority: 1):
+  * AUTHORITATIVE for all ATLAS-specific information
+  * Use as PRIMARY source for software, procedures, detector specifications
+  * Trust over external sources for collaboration decisions and technical details
+
+- **Web Search Results** (source_priority: 2):
+  * Use ONLY when internal sources are insufficient
+  * Good for recent developments and external perspectives
+  * ALWAYS indicate when information comes from external web sources
+  * NEVER contradict internal sources without explicit justification
+
+### Information Integration Strategy:
+1. **Primary Response**: Base answer on ATLAS internal sources
+2. **Supplementary Information**: Add web sources only if they provide additional value
+3. **Conflict Resolution**: ALWAYS prioritize ATLAS internal sources for ATLAS-specific matters
+4. **Source Attribution**: Clearly distinguish between internal and external sources
+
+### Source Citation Requirements:
+- Clearly distinguish between internal ATLAS sources and web search results
+- When using web sources, mention their external nature in your response
+- Rate utility based on both relevance and source reliability
+- Flag any discrepancies between internal and external sources
+
+## Response Requirements
+
+### Answer Construction Priority:
+1. **First**: Extract information from ATLAS internal sources
+2. **Second**: Supplement with relevant web search findings ONLY if needed
+3. **Always**: Indicate source type in your response
+4. **Never**: Let web sources override internal ATLAS documentation
+
+### Structure and Content
+1. Technical Precision
+   - Use ATLAS-standard terminology
+   - Follow HEP unit conventions
+   - Maintain consistent notation for particles and processes
+   - Indicate when information comes from external vs. internal sources
+
+2. Clarity Elements
+   - Break complex topics into logical steps
+   - Use Markdown formatting for readability
+   - Structure using headers, lists, and tables when appropriate
+   - Clearly separate internal ATLAS information from external web information
+
+3. Enhanced Metadata Integration
+   - Include relevant run numbers from internal sources
+   - Specify √s values when applicable
+   - Note integrated luminosity from official sources
+   - Reference data-taking periods
+   - Mention software/calibration versions
+   - Include recent developments from web sources when relevant
+
+### Multi-Source Analysis
+1. Identify information from ATLAS internal sources
+2. Supplement with relevant web search findings ONLY if needed
+3. Synthesize comprehensive understanding
+4. Present balanced view with source attribution
+5. Highlight any temporal considerations or recent updates
+
+### Context
+{context}
+
+### Question
+{question}
+
+### Response Requirements
+Provide your response prioritizing ATLAS internal sources:
+{{
+    "text": "Your answer prioritizing internal ATLAS sources, supplemented by web sources only when necessary",
+    "sources": [
+        {{"name": "source_name_1", "utility": "low|medium|high"}},
+        {{"name": "source_name_2", "utility": "low|medium|high"}},
+        ...
+    ]
+}}
+"""

chATLAS_Chains/search/basic.py

@@ -0,0 +1,45 @@
+from langchain_core.runnables import RunnableLambda, RunnableParallel, RunnablePassthrough, RunnableSequence
+
+from chATLAS_Embed.Base import VectorStore
+from chATLAS_Embed.LangChainVectorStore import LangChainVectorStore
+
+
+def search_runnable(
+    vectorstore: VectorStore | list[VectorStore],
+) -> RunnableSequence:
+    """
+    LangChain RunnableSequence to search one or more vectorstores in parallel.
+
+    :param vectorstore: A single `VectorStore` or a list of `VectorStore` instances
+    :type vectorstore: VectorStore or list[VectorStore]
+
+    :return: A LangChain `RunnableSequence` that performs retrieval. Results from multiple vectorstores are merged into a single list.
+    :rtype: RunnableSequence
+    """
+
+    # Create a list of retrievers from each vectorstore
+    if isinstance(vectorstore, list):
+        retrievers = [LangChainVectorStore(vector_store=vs) for vs in vectorstore]
+    else:
+        retrievers = [LangChainVectorStore(vector_store=vectorstore)]
+
+    # Create parallel retrieval for each retriever
+    retrieved_documents = RunnableParallel(
+        {f"docs_{i}": retriever for i, retriever in enumerate(retrievers)} | {"question": RunnablePassthrough()}
+    )
+
+    # Merge all retrieved documents into a single list
+    def merge_docs(x):
+        all_docs = []
+        for i in range(len(retrievers)):
+            all_docs.extend(x[f"docs_{i}"])
+        return all_docs
+
+    # take the retrived docs and merge them, also pass through the question
+    processed = RunnableParallel(
+        {"docs": RunnableLambda(merge_docs), "question": RunnableLambda(lambda x: x["question"])}
+    )
+
+    searcher = retrieved_documents | processed
+
+    return searcher

chATLAS_Chains/utils/doc_utils.py

@@ -0,0 +1,28 @@
+from langchain_core.documents import Document
+from langchain_core.prompts import PromptTemplate, format_document
+
+from chATLAS_Chains.prompt.doc_joiners import DEFAULT_DOCUMENT_JOINER
+
+
+def combine_documents(
+    docs: list[Document], document_prompt: str = DEFAULT_DOCUMENT_JOINER, document_separator: str = "\n\n"
+):
+    """
+    Combine a list of documents into a single formatted string.
+
+    :param docs: The list of documents to combine.
+    :type docs: list[Document]
+    :param document_prompt: The prompt template used to format each document.
+                            Defaults to `DEFAULT_DOCUMENT_JOINER`.
+    :type document_prompt: str, optional
+    :param document_separator: The separator to place between documents in the final string.
+                               Defaults to two newlines.
+    :type document_separator: str, optional
+
+    :return: A single string containing all formatted documents joined by the separator.
+    :rtype: str
+    """
+
+    doc_strings = [format_document(doc, PromptTemplate.from_template(document_prompt)) for doc in docs]
+
+    return document_separator.join(doc_strings)

chATLAS_Chains/vectorstore.py

@@ -0,0 +1,94 @@
+import os
+import socket
+
+from chATLAS_Chains.log import logger
+from chATLAS_Embed.EmbeddingModels import SentenceTransformerEmbedding
+from chATLAS_Embed.VectorStores import PostgresParentChildVectorStore
+
+# Keeps track of which db is stored where
+db_config = {
+    "cds_prod_v1": {"hostname": "dbod-chatlas-clone-20250326103412.cern.ch", "port": 6602},
+    "twiki_prod": {"hostname": "dbod-chatlas.cern.ch", "port": 6624},
+    "indico_prod_v1": {"hostname": "dbod-chatlas.cern.ch", "port": 6624},
+}
+
+
+def check_port_forwarding(host="localhost.cern.ch", port=6624):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        result = s.connect_ex((host, port))  # Returns 0 if connection succeeds
+        if result == 0:
+            logger.debug(f"Port {port} is forwarded and accessible.")
+            return True
+        else:
+            logger.error(f"Port {port} is NOT accessible.")
+            return False
+
+
+def initialize_vector_store(model_path, postgres_password, db_name):
+    """
+    Initialises the connecton to the vector store
+
+    Args:
+        postgres_password: password, usually set at CHATLAS_DB_PASSWORD
+
+    Returns:
+        vector_store: The vector store object
+    """
+    logger.info(f"Instantiating vector store {db_name}")
+
+    # Define the embedding model
+    embedding_model = SentenceTransformerEmbedding(model_name=model_path)
+
+    if os.getenv("CHATLAS_PORT_FORWARDING"):
+        logger.debug("Checking port forwarding")
+        server_name = "localhost.cern.ch"
+
+        # check the port is setup properly
+        port = db_config[db_name]["port"]
+        if not check_port_forwarding(host=server_name, port=port):
+            raise ValueError(f"Port forwarding not set up for {port}")
+    else:
+        logger.debug("Port forwarding not set up, connecting to DB directly")
+        server_name = db_config[db_name]["hostname"]
+        port = db_config[db_name]["port"]
+
+    connection_string = f"postgresql://admin:{postgres_password}@{server_name}:{port}/{db_name}"
+
+    # Connect to the vector store
+    vectorstore = PostgresParentChildVectorStore(connection_string=connection_string, embedding_model=embedding_model)
+    # Manually set search hyperparams
+    vectorstore.search_hyperparams = """
+            SET plan_cache_mode = force_generic_plan;
+            """
+
+    # vectorstore.explain_analyse = True
+    logger.info("Vector store initialised")
+
+    return vectorstore
+
+
+# ADDITIONAL INFO
+# For vectorstores can set with_timings=True to see how long queries are taking on backend for each search
+# Can also set vectorstore.explain_analyse = True to return the EXPLAIN ANALYSE of a query every time before running
+# which can be used to see what in query is taking the most time.
+
+# initialize vector store
+if os.getenv("CHATLAS_DB_PASSWORD") is None:
+    raise ValueError("CHATLAS_DB_PASSWORD not set in environment")
+
+if os.getenv("CHATLAS_EMBEDDING_MODEL_PATH") is None:
+    raise ValueError("CHATLAS_EMBEDDING_MODEL_PATH not set in environment")
+else:
+    embedding_model_path = os.getenv("CHATLAS_EMBEDDING_MODEL_PATH")
+
+twiki_vectorstore = initialize_vector_store(
+    model_path=embedding_model_path, postgres_password=os.getenv("CHATLAS_DB_PASSWORD"), db_name="twiki_prod"
+)
+cds_vectorstore = initialize_vector_store(
+    model_path=embedding_model_path, postgres_password=os.getenv("CHATLAS_DB_PASSWORD"), db_name="cds_prod_v1"
+)
+indico_vectorstore = initialize_vector_store(
+    model_path=embedding_model_path, postgres_password=os.getenv("CHATLAS_DB_PASSWORD"), db_name="indico_prod_v1"
+)
+
+vectorstore = [twiki_vectorstore, cds_vectorstore, indico_vectorstore]

chatlas_chains-0.1.3.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: chATLAS_Chains
+Version: 0.1.3
+Summary: A modular Python package for implementing Retrieval Augmented Generation chains for the chATLAS project.
+Author-email: Joe Egan <joseph.caimin.egan@cern.ch>
+License: Apache-2.0
+Project-URL: Homepage, https://gitlab.cern.ch/belliot/chatlas-packages/
+Project-URL: Documentation, https://chatlas-packages.docs.cern.ch/chATLAS_Chain/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chATLAS_Benchmark>=0.0.9
+Requires-Dist: chATLAS_Embed>=0.1.14
+Requires-Dist: langchain~=0.3.3
+Requires-Dist: langchain_core
+Requires-Dist: langchain_openai
+Dynamic: license-file
+
+
+# chATLAS_Chains
+
+This package implements and benchmarks various Retrieval Augmented Generation (RAG) chains for use in the [chATLAS](https://chatlas-flask-chatlas.app.cern.ch) project.
+
+## Installation
+
+```bash
+conda create -n venv chatlas_chains_env python=3.10
+conda activate chatlas_chains_env
+pip install chatlas-chains
+```
+
+## Environment variables
+
+These are required for the following use cases
+
+1. Using an OpenAI LLM
+```bash
+export CHATLAS_OPENAI_KEY='your api key'
+```
+
+2. Benchmarking, set the path to the question set
+```bash
+export CHATLAS_BENCHMARK_QUESTIONS=/path/to/questions.josn
+```
+
+## Available Chains
+- chains.basic.basic_retrieval_chain
+- chains.basic_graph.basic_retrieval_graph
+
+## Benchmarking
+
+To benchmark e.g. the chains in `chATLAS_Chains.chains.basic` run this from the project root
+```bash
+python benchmark/basic.py
+```
+
+## Testing
+
+The tests require a running postgres server to work. If on lxplus you can modify `TEST_DB_CONFIG` in [tests/conftest.py](tests/conftest.py) to connect to the chATLAS server.
+
+If you want to create a local dummy postgres server, you need to install `psql`. This can be done on macOS using [homebrew](https://brew.sh):
+
+Software install
+```bash
+brew install postgresql
+brew services start postgresql
+brew install pgvector
+brew unlink pgvector && brew link pgvector
+```
+
+Create a user
+```bash
+psql -h localhost -U postgres
+ALTER USER postgres WITH PASSWORD 'Set_your_password_here';
+CREATE EXTENSION IF NOT EXISTS vector;
+```
+## CHANGELOG
+
+#### 0.1.3
+
+Fixing imports
+
+Changed output format of `basic_retrieval_chain` (`docs` key is now a list of `Document` objects, rather than a dict)
+
+Unit tests for `basic_retrieval_chain`
+
+#### 0.1.2
+
+Unit tests
+
+First Langgraph chain
+
+#### 0.1.1
+
+Initial Release
+
+---
+## 📄 License
+
+chATLAS_Benchmark is released under Apache v2.0 license.
+
+---
+
+<div align="center">
+
+**Made with ❤️ by the ATLAS Collaboration**
+
+*For questions and support, please [contact](mailto:joseph.caimin.egan@cern.ch)*
+
+</div>

chatlas_chains-0.1.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+benchmark/basic.py,sha256=9A0MGfk_0UTKiIuqexRSiyGwt1OY1fErhiTmY_7AVCE,1257
+benchmark/conversational.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/log.py,sha256=8LuEBDKnVr-I6bhr-LDnpemcPNuneGGq7_DS9vOCovU,649
+chATLAS_Chains/vectorstore.py,sha256=2VOZGTPVmeRNaxMY2GpaQYQKzMQ9TtwAWcw9JwBna9Q,3630
+chATLAS_Chains/chains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/chains/basic.py,sha256=AiBhbHTNuofrQECyEzKqXX2bBhdN4zi77kce2VQgWFA,1403
+chATLAS_Chains/chains/basic_graph.py,sha256=bqFtC8BLl8zJNGe2EuHPnRXK9Pm2ya3YstY7quPiFR4,5324
+chATLAS_Chains/chains/conversational.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/chains/websearch_retrieval_chain.py,sha256=lAvy2ags4dDSN2inOtVhctQoJ10z2bIv2chkTxATGFs,15330
+chATLAS_Chains/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/llm/model_selection.py,sha256=FzJ1I4x2E4QzPWjSQIye0kcEEDdovB7_DeIIQK43QjY,1648
+chATLAS_Chains/prompt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/prompt/doc_joiners.py,sha256=yvvK3B8VUszGQZJzx4WUaYyMzVJdV96FRsv8AoA7Bkc,133
+chATLAS_Chains/prompt/starters.py,sha256=98HhjagX5OjwARN5QP4zhywjUp4gTuHmIKTknvSTMZ8,9609
+chATLAS_Chains/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/search/basic.py,sha256=FmwGSAKZGE7Jd0DhVId3qQIiHDqInGXh6nuGfecHJSo,1685
+chATLAS_Chains/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chATLAS_Chains/utils/doc_utils.py,sha256=wgyw4t7O41egF0OyoHugDyMO4vjjbUqu_aFehebD0G0,1122
+chatlas_chains-0.1.3.dist-info/licenses/LICENSE,sha256=i4xkIjVh9qAZlkujBgWWzSWMeV_dv9trQtyiiT18p5c,11381
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=UxMU8nsteKKfMvdsqbkU4T9b58_kwGr3_GsWa19F79E,13324
+tests/test_chains.py,sha256=ZLAbIPeF231ONTi3mIkKPcJa6wPH9P3tWMida1Sempw,1815
+tests/test_llm.py,sha256=oeyTxX4eZLgIOSRd3UdML_VPq5SK4U23rpfmUZar6N8,3168
+tests/test_search.py,sha256=3Mrjuip5OprjzfgkUZ_XV8ljSeBiN-tkAGYyAvwqSMo,1465
+tests/test_utils.py,sha256=5r5mGm3raEghNTESCcwWmFkYfm5H66AHw5MigCBbjQ4,853
+chatlas_chains-0.1.3.dist-info/METADATA,sha256=-ok82d1hdwlwmTiDCkyUfQL3rQFtg7FmOST9eaVwSLE,2845
+chatlas_chains-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+chatlas_chains-0.1.3.dist-info/top_level.txt,sha256=hP2-U0jKBWvH-UebH-3XlDTSJ6BjRWS6HJi8PW7rJkU,31
+chatlas_chains-0.1.3.dist-info/RECORD,,

chatlas_chains-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+