quantalogic 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

quantalogic/agent_config.py

@@ -24,6 +24,8 @@ from quantalogic.tools import (
     SearchDefinitionNames,
     TaskCompleteTool,
     WriteFileTool,
+    DuckDuckGoSearchTool,
+    WikipediaSearchTool,
 )
 
 MODEL_NAME = "deepseek/deepseek-chat"
@@ -124,6 +126,8 @@ def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
         MarkitdownTool(),
         LLMTool(model_name=model_name),
         DownloadHttpFileTool(),
+        WikipediaSearchTool(),
+        DuckDuckGoSearchTool(),
     ]
 
     if vision_model_name:

quantalogic/generative_model.py

@@ -1,5 +1,7 @@
 """Generative model module for AI-powered text generation."""
 
+import functools
+
 import openai
 from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter
 from loguru import logger
@@ -83,6 +85,7 @@ class GenerativeModel:
         logger.debug(f"Initializing GenerativeModel with model={model}, temperature={temperature}")
         self.model = model
         self.temperature = temperature
+        self._get_model_info_cached = functools.lru_cache(maxsize=32)(self._get_model_info_impl)
 
     # Define retriable exceptions based on LiteLLM's exception mapping
     RETRIABLE_EXCEPTIONS = (
@@ -235,21 +238,46 @@ class GenerativeModel:
         litellm_messages.append({"role": "user", "content": str(prompt)})
         return token_counter(model=self.model, messages=litellm_messages)
 
-    def get_model_info(self) -> dict | None:
-        """Get information about the model."""
-        logger.debug(f"Retrieving model info for {self.model}")
-        model_info = get_model_info(self.model)
-
-        if not model_info:
-            logger.debug("Model info not found, trying without openrouter/ prefix")
-            model_info = get_model_info(self.model.replace("openrouter/", ""))
-
-        if model_info:
-            logger.debug(f"Model info retrieved: {model_info.keys()}")
-        else:
-            logger.debug("No model info available")
-
-        return model_info
+    def _get_model_info_impl(self, model_name: str) -> dict:
+        """Get information about the model with prefix fallback logic.
+        
+        Attempts to find model info by progressively removing provider prefixes.
+        Raises ValueError if no valid model configuration is found.
+        Results are cached to improve performance.
+        
+        Example:
+            openrouter/openai/gpt-4o-mini → openai/gpt-4o-mini → gpt-4o-mini
+        """
+        original_model = model_name
+        
+        while True:
+            try:
+                logger.debug(f"Attempting to retrieve model info for: {model_name}")
+                model_info = get_model_info(model_name)
+                if model_info:
+                    logger.debug(f"Found model info for {model_name}: {model_info}")
+                    return model_info
+            except Exception:
+                pass
+                
+            # Try removing one prefix level
+            parts = model_name.split('/')
+            if len(parts) <= 1:
+                break
+            model_name = '/'.join(parts[1:])
+            
+        error_msg = f"Could not find model info for {original_model} after trying: {self.model} → {model_name}"
+        logger.error(error_msg)
+        raise ValueError(error_msg)
+
+    def get_model_info(self, model_name: str = None) -> dict:
+        """Get cached information about the model.
+        
+        If no model name is provided, uses the current model.
+        """
+        if model_name is None:
+            model_name = self.model
+        return self._get_model_info_cached(model_name)
 
     def get_model_max_input_tokens(self) -> int:
         """Get the maximum number of input tokens for the model."""

quantalogic/main.py

@@ -32,7 +32,6 @@ from quantalogic.agent_config import (  # noqa: E402
 )
 from quantalogic.interactive_text_editor import get_multiline_input  # noqa: E402
 from quantalogic.print_event import console_print_events  # noqa: E402
-
 from quantalogic.search_agent import create_search_agent
 
 AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic","search"]

quantalogic/search_agent.py

@@ -1,16 +1,26 @@
 from quantalogic.agent import Agent
-from quantalogic.tools import InputQuestionTool, SerpApiSearchTool, TaskCompleteTool, WikipediaSearchTool, ReadFileBlockTool,ReadFileTool, MarkitdownTool, RipgrepTool
+from quantalogic.tools import (
+    InputQuestionTool,
+    SerpApiSearchTool,
+    DuckDuckGoSearchTool,
+    TaskCompleteTool,
+    WikipediaSearchTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    MarkitdownTool,
+    RipgrepTool
+)
 
 
 def create_search_agent(model_name: str) -> Agent:
-    """Creates and configures a search agent with web and knowledge search tools.
+    """Creates and configures a search agent with web, knowledge, and privacy-focused search tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
 
     Returns:
         Agent: A fully configured search agent instance with:
-            - Web search capabilities (SerpAPI)
+            - Web search capabilities (SerpAPI, DuckDuckGo)
             - Knowledge search capabilities (Wikipedia)
             - Basic interaction tools
     """
@@ -22,6 +32,7 @@ def create_search_agent(model_name: str) -> Agent:
     tools = [
         # Search tools
         SerpApiSearchTool(),  # Web search capabilities
+        DuckDuckGoSearchTool(),  # Privacy-focused web search
         WikipediaSearchTool(),  # Knowledge search capabilities
         # Basic interaction tools
         TaskCompleteTool(),  # Marks task completion

quantalogic/tools/__init__.py

@@ -18,6 +18,7 @@ from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
 from .search_definition_names import SearchDefinitionNames
 from .serpapi_search_tool import SerpApiSearchTool
+from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .task_complete_tool import TaskCompleteTool
 from .tool import Tool, ToolArgument
 from .unified_diff_tool import UnifiedDiffTool
@@ -27,6 +28,7 @@ from .write_file_tool import WriteFileTool
 __all__ = [
     "WikipediaSearchTool",
     "SerpApiSearchTool",
+    "DuckDuckGoSearchTool",
     "Tool",
     "ToolArgument",
     "TaskCompleteTool",

quantalogic/tools/duckduckgo_search_tool.py

@@ -0,0 +1,214 @@
+"""Tool for interacting with DuckDuckGo for search results."""
+
+from duckduckgo_search import DDGS
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class DuckDuckGoSearchTool(Tool):
+    """Tool for retrieving search results from DuckDuckGo.
+
+    This tool provides a convenient interface to DuckDuckGo's search capabilities,
+    supporting multiple search types and structured JSON output.
+
+    Example usage:
+    ```python
+    tool = DuckDuckGoSearchTool()
+    results = tool.execute(
+        query="machine learning",
+        search_type="text",
+        max_results=10,
+        region="us-en",
+        safesearch="moderate"
+    )
+    print(results)
+    ```
+
+    The tool handles:
+    - Query validation
+    - API error handling
+    - Multiple search types (text, images, videos, news)
+    - Scope filtering (region, safesearch, timelimit)
+    - JSON result formatting
+    """
+
+    name: str = "duckduckgo_tool"
+    description: str = (
+        "Retrieves search results from DuckDuckGo. "
+        "Provides structured output of search results."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="query",
+            arg_type="string",
+            description="The search query to execute",
+            required=True,
+            example="machine learning",
+        ),
+        ToolArgument(
+            name="max_results",
+            arg_type="int",
+            description="Maximum number of results to retrieve (1-50)",
+            required=True,
+            default="10",
+            example="20",
+        ),
+        ToolArgument(
+            name="search_type",
+            arg_type="string",
+            description="Type of search to perform (text, images, videos, news)",
+            required=False,
+            default="text",
+            example="images",
+        ),
+        ToolArgument(
+            name="region",
+            arg_type="string",
+            description="Region for search results (e.g., 'wt-wt', 'us-en')",
+            required=False,
+            default="wt-wt",
+            example="us-en",
+        ),
+        ToolArgument(
+            name="safesearch",
+            arg_type="string",
+            description="Safesearch level ('on', 'moderate', 'off')",
+            required=False,
+            default="moderate",
+            example="moderate",
+        ),
+        ToolArgument(
+            name="timelimit",
+            arg_type="string",
+            description="Time limit for results (e.g., 'd' for day, 'w' for week)",
+            required=False,
+            default=None,
+            example="d",
+        ),
+    ]
+
+    def execute(
+        self,
+        query: str,
+        max_results: int = 10,
+        search_type: str = "text",
+        region: str = "wt-wt",
+        safesearch: str = "moderate",
+        timelimit: str = None,
+    ) -> str:
+        """Execute a search query using DuckDuckGo and return results.
+
+        Args:
+            query: The search query to execute
+            max_results: Maximum number of results to retrieve (1-50)
+            search_type: Type of search to perform (text, images, videos, news)
+            region: Region for search results (e.g., "wt-wt", "us-en")
+            safesearch: Safesearch level ("on", "moderate", "off")
+            timelimit: Time limit for results (e.g., "d" for day, "w" for week)
+
+        Returns:
+            Pretty-printed JSON string of search results.
+
+        Raises:
+            ValueError: If any parameter is invalid
+            RuntimeError: If search fails
+        """
+        # Handle empty string parameters by setting to defaults
+        query = str(query) if query else query
+        search_type = search_type if search_type else "text"
+        region = region if region else "wt-wt"
+        safesearch = safesearch if safesearch else "moderate"
+        timelimit = timelimit if timelimit else None
+
+        # Validate and convert query
+        if not query:
+            raise ValueError("Query must be a non-empty string")
+        try:
+            query = str(query)
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Query must be convertible to string: {str(e)}")
+
+        # Validate and convert max_results
+        try:
+            max_results = int(max_results)
+            if max_results < 1 or max_results > 50:
+                raise ValueError("Number of results must be between 1 and 50")
+        except (TypeError, ValueError) as e:
+            raise ValueError(f"Invalid number of results: {str(e)}")
+
+        # Validate search_type
+        if search_type not in ["text", "images", "videos", "news"]:
+            raise ValueError("search_type must be one of: text, images, videos, news")
+
+        # Validate safesearch
+        if safesearch not in ["on", "moderate", "off"]:
+            raise ValueError("safesearch must be one of: on, moderate, off")
+
+        try:
+            ddgs = DDGS()
+
+            # Perform the appropriate search based on search_type
+            if search_type == "text":
+                results = ddgs.text(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "images":
+                results = ddgs.images(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "videos":
+                results = ddgs.videos(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+            elif search_type == "news":
+                results = ddgs.news(
+                    keywords=query,
+                    region=region,
+                    safesearch=safesearch,
+                    timelimit=timelimit,
+                    max_results=max_results,
+                )
+
+            # Return pretty-printed JSON
+            import json
+            return json.dumps(results, indent=4, ensure_ascii=False)
+
+        except Exception as e:
+            raise RuntimeError(f"Search failed: {str(e)}")
+
+
+def main():
+    """Demonstrate DuckDuckGoSearchTool functionality."""
+    try:
+        tool = DuckDuckGoSearchTool()
+
+        # Test basic search functionality
+        print("Testing DuckDuckGoSearchTool with sample query...")
+        results = tool.execute(query="Python programming", max_results=3)
+        print(results)
+
+        # Test error handling
+        print("\nTesting error handling with invalid query...")
+        try:
+            tool.execute(query="")
+        except ValueError as e:
+            print(f"Caught expected ValueError: {e}")
+
+    except Exception as e:
+        print(f"Error in main: {e}")
+
+
+if __name__ == "__main__":
+    main()

quantalogic/tools/markitdown_tool.py

@@ -47,50 +47,53 @@ class MarkitdownTool(Tool):
         Returns:
             str: The Markdown content or a success message.
         """
-        # Handle tilde expansion for local paths
-        if file_path.startswith("~"):
-            file_path = os.path.expanduser(file_path)
-
-        # Handle URL paths
-        if file_path.startswith(("http://", "https://")):
-            try:
-                # Create a temporary file
-                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-                    temp_path = temp_file.name
-                    # Download the file from URL
-                    download_http_file(file_path, temp_path)
-                    # Use the temporary file path for conversion
-                    file_path = temp_path
-                    is_temp_file = True
-            except Exception as e:
-                return f"Error downloading file from URL: {str(e)}"
-        else:
-            is_temp_file = False
-
         try:
-            from markitdown import MarkItDown
+            # Handle URL paths first
+            if file_path.startswith(("http://", "https://")):
+                try:
+                    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                        temp_path = temp_file.name
+                        download_http_file(file_path, temp_path)
+                        file_path = temp_path
+                        is_temp_file = True
+                except Exception as e:
+                    return f"Error downloading file from URL: {str(e)}"
+            else:
+                is_temp_file = False
+                # Handle local paths
+                if file_path.startswith("~"):
+                    file_path = os.path.expanduser(file_path)
+                if not os.path.isabs(file_path):
+                    file_path = os.path.abspath(file_path)
+                
+                # Verify file exists
+                if not os.path.exists(file_path):
+                    return f"Error: File not found at path: {file_path}"
 
+            from markitdown import MarkItDown
             md = MarkItDown()
             result = md.convert(file_path)
 
             if output_file_path:
+                # Ensure output directory exists
+                output_dir = os.path.dirname(output_file_path)
+                if output_dir and not os.path.exists(output_dir):
+                    os.makedirs(output_dir)
+                    
                 with open(output_file_path, "w", encoding="utf-8") as f:
                     f.write(result.text_content)
-                output_message = f"Markdown content successfully written to {output_file_path}"
-            else:
-                # Truncate content if it exceeds MAX_LINES
-                lines = result.text_content.splitlines()
-                if len(lines) > MAX_LINES:
-                    truncated_content = "\n".join(lines[:MAX_LINES])
-                    output_message = f"Markdown content truncated to {MAX_LINES} lines:\n{truncated_content}"
-                else:
-                    output_message = result.text_content
-
-            return output_message
+                return f"Markdown content successfully written to {output_file_path}"
+            
+            # Handle content truncation
+            lines = result.text_content.splitlines()
+            if len(lines) > MAX_LINES:
+                truncated_content = "\n".join(lines[:MAX_LINES])
+                return f"Markdown content truncated to {MAX_LINES} lines:\n{truncated_content}"
+            return result.text_content
+
         except Exception as e:
             return f"Error converting file to Markdown: {str(e)}"
         finally:
-            # Clean up temporary file if it was created
             if is_temp_file and os.path.exists(file_path):
                 os.remove(file_path)
 

quantalogic/utils/check_version.py

@@ -16,7 +16,8 @@ def check_if_is_latest_version() -> (bool,str|None):
         response = requests.get("https://pypi.org/pypi/quantalogic/json", timeout=5)
         response.raise_for_status()
         latest_version = response.json()["info"]["version"]
-        return version.parse(current_version) < version.parse(latest_version), latest_version
+        has_new_version = version.parse(current_version) < version.parse(latest_version)
+        return has_new_version, latest_version
     except (requests.RequestException, KeyError):
         return False, None
 

{quantalogic-0.2.13.dist-info → quantalogic-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.13
+Version: 0.2.15
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: boto3 (>=1.35.86,<2.0.0)
 Requires-Dist: click (>=8.1.8,<9.0.0)
+Requires-Dist: duckduckgo-search (>=7.2.1,<8.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
 Requires-Dist: google-search-results (>=2.4.2,<3.0.0)

{quantalogic-0.2.13.dist-info → quantalogic-0.2.15.dist-info}/RECORD

@@ -1,16 +1,16 @@
 quantalogic/__init__.py,sha256=HFk7_19UzHzYwvPzb9QTQ4w_lPwTTPda61AYb8qggZY,686
 quantalogic/agent.py,sha256=ROE9hJe9b2eRhhuH64-rxWWHsXO4lnjV-PdjqqdxS_g,26653
-quantalogic/agent_config.py,sha256=iPJjY8OZDOoV7lYuL5TAj5JXPcRL4VUOzu5CZVeB3Sg,4520
+quantalogic/agent_config.py,sha256=RWXnRpZeT_twtDIFVHY0K7EdHLmEbb8LvVGRr0oc3Q8,4634
 quantalogic/coding_agent.py,sha256=FrodyypgtOOV-AvJiQP8PLkUIDQkDrye26dbOxIEKjM,3486
 quantalogic/event_emitter.py,sha256=jqot2g4JRXc88K6PW837Oqxbf7shZfO-xdPaUWmzupk,7901
-quantalogic/generative_model.py,sha256=LKuv_aRpEwMgeEUzHg4r3XkQdPHAr4Mu-ZfWIAqR4Ik,10651
+quantalogic/generative_model.py,sha256=pDbjwPfOQEtuZBk8o9uT8vxjauFfXwTM7GkMco73jfU,11787
 quantalogic/interactive_text_editor.py,sha256=kYeTA2qej5kxtPvAUHy_Dr2MhrGQAyenLFpW9mU9Rmw,6855
-quantalogic/main.py,sha256=LitSK1GfFgBAAbe6WiL9xOPyu9-UZB3PDqWINH_cPLU,11144
+quantalogic/main.py,sha256=jIIFuQQXK29F-Ue95H6Wv0g-u0Q1VYTNRzZJlXP57NI,11143
 quantalogic/memory.py,sha256=zbtRuM05jaS2lJll-92dt5JfYVLERnF_m_9xqp2x-k0,6304
 quantalogic/model_names.py,sha256=UZlz25zG9B2dpfwdw_e1Gw5qFsKQ7iME9FJh9Ts4u6s,938
 quantalogic/print_event.py,sha256=nl1aRdYnsU72SRezafePF82zKtrqGfY8OoTx2QfbdE8,2206
 quantalogic/prompts.py,sha256=BHIST57DYcTeTb7rvV1QkGLt0_B8Wk8a_9tsnsN6suk,3547
-quantalogic/search_agent.py,sha256=HD13Ug8Zn6GpCn_3WwzNE0fhyLoitldv9lwmZ4SxCfk,1545
+quantalogic/search_agent.py,sha256=kGHu-tVm85rEMx7dpcxScAraVC5V0Wp_JeIZ42iNJRI,1700
 quantalogic/server/__init__.py,sha256=8sz_PYAUCrkM6JM5EAUeIzNM4NPW6j6UT72JVkc21WQ,91
 quantalogic/server/agent_server.py,sha256=38GEK_MpLp--CX_dCkopTFOU7KcGuOw4-GciwmRJyyg,22502
 quantalogic/server/models.py,sha256=nVUGWElOsUw8QnRCGJylk25wCew_5gohe6nldYighUA,1322
@@ -20,9 +20,10 @@ quantalogic/server/static/js/event_visualizer.js,sha256=eFkkWyNZw3zOZlF18kxbfsWq
 quantalogic/server/static/js/quantalogic.js,sha256=x7TrlZGR1Y0WLK2DWl1xY847BhEWMPnL0Ua7KtOldUc,22311
 quantalogic/server/templates/index.html,sha256=nDnXJoQEm1vXbhXtgaYk0G5VXj0wwzE6KrqEDhHFpj4,7773
 quantalogic/tool_manager.py,sha256=JAC5E5kLfYzYJx0QRIWbG14q1hlkOcwJFBG7HE8twpU,2425
-quantalogic/tools/__init__.py,sha256=ZjcsmkDkg79P8EkH7SkyqP2KiJndRqBjEji7KUDv6mw,1653
+quantalogic/tools/__init__.py,sha256=hAHP1-jrDAbvzoo-noV2mokYbUZ4Em7agagnq3W5dH4,1738
 quantalogic/tools/agent_tool.py,sha256=MXCXxWHRch7VK4UWhtRP1jeI8Np9Ne2CUGo8vm1oZiM,3064
 quantalogic/tools/download_http_file_tool.py,sha256=wTfanbXjIRi5-qrbluuLvNmDNhvmYAnlMVb3dO8C2ss,2210
+quantalogic/tools/duckduckgo_search_tool.py,sha256=xVaEb_SUK5NL3lwMQXj1rGQYYvNT-td-qaB9QCes27Q,7014
 quantalogic/tools/edit_whole_content_tool.py,sha256=nXmpAvojvqvAcqNMy1kUKZ1ocboky_ZcnCR4SNCSPgw,2360
 quantalogic/tools/elixir_tool.py,sha256=fzPPtAW-Koy9KB0r5k2zV1f1U0WphL-LXPPOBkeNkug,7652
 quantalogic/tools/execute_bash_command_tool.py,sha256=fnx-zSPpxR2EofaleygAorrR21gRs43jBWh7IBAoNKw,4131
@@ -40,7 +41,7 @@ quantalogic/tools/language_handlers/typescript_handler.py,sha256=L4vuJMYxKO3_83d
 quantalogic/tools/list_directory_tool.py,sha256=8Hy38DelSh-mRqS_uDLpeBYoHLtEy5ji77xI-TJu3Ms,4176
 quantalogic/tools/llm_tool.py,sha256=9SNApqvNT2qF9GWxEVzMKq8XiVtc-UoyamhsIWvgZQI,5456
 quantalogic/tools/llm_vision_tool.py,sha256=OP2B6bYjnKvO7TjSG0gEtwvV5L0m4uFDWAaU54cOG3w,4913
-quantalogic/tools/markitdown_tool.py,sha256=GHJMPdWmwF-CBu3vHWhy-kXJYRDluFkh18KN06yNHOc,4101
+quantalogic/tools/markitdown_tool.py,sha256=lpbJBLx43_x2DjiZAV1HSidkHeqkkV0KvgeLG2fphK4,4339
 quantalogic/tools/nodejs_tool.py,sha256=zdnE0VFj_5786uR2L0o-SKR0Gk8L-U7rdj7xGHJYIq0,19905
 quantalogic/tools/python_tool.py,sha256=70HLbfU2clOBgj4axDOtIKzXwEBMNGEAX1nGSf-KNNQ,18156
 quantalogic/tools/read_file_block_tool.py,sha256=FTcDAUOOPQOvWRjnRI6nMI1Upus90klR4PC0pbPP_S8,5266
@@ -56,7 +57,7 @@ quantalogic/tools/wikipedia_search_tool.py,sha256=bdZ_0dYTxpEfU04tBFsatnLM5P9Z3k
 quantalogic/tools/write_file_tool.py,sha256=_mx9_Zjg2oMAAVzlcHEKjZVZUxQVgbRfcoMKgWnoZcg,3764
 quantalogic/utils/__init__.py,sha256=Ltq7tzLuHCl9BpCvfRVA9Sjrtp1RJesrn7G980lbl_c,563
 quantalogic/utils/ask_user_validation.py,sha256=F0jkbFJVXAImcSSP7op6dov5i80hRvZGRvBHbfcZrxg,340
-quantalogic/utils/check_version.py,sha256=gGfT7hn64Rsrs-wWMJQJsoP4dGvyR6Q7AHHFogpmbLs,1094
+quantalogic/utils/check_version.py,sha256=grxTfJE85GMue1OAk8z8_q8tjEJxQ8RO6fN3fJ_qedg,1136
 quantalogic/utils/download_http_file.py,sha256=FTN3brq9WvCFvuBX-lYAhjsdYTzQT4m9m2vqlcyjkNk,3472
 quantalogic/utils/get_coding_environment.py,sha256=ujZ2_nDryrLWe6ZUalSu9WDG6t53UJFn7FJ_ER7Jixc,389
 quantalogic/utils/get_environment.py,sha256=7wWruSHYTUlnQWW27qU3WFYZnncqqqdofsxAsUU7lhw,875
@@ -67,8 +68,8 @@ quantalogic/utils/read_http_text_content.py,sha256=n3IayT5KcqctIVVF2gOQQAMf3Ow6e
 quantalogic/version.py,sha256=ea_cRutaQk5_lwlLbUUvPFuOT7Of7-gAsDl7wdveS-g,107
 quantalogic/xml_parser.py,sha256=cTRorr5sVfkIzH72M0C-GQ9ROGPiz2FTT66U9ndjzhE,9538
 quantalogic/xml_tool_parser.py,sha256=lsVzClZBrZan7wjCuCKnGHWzksXI3VMy_vWthxu2_bo,3738
-quantalogic-0.2.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.2.13.dist-info/METADATA,sha256=-OOOtDoX2-bad_R1v3kV-Zv_ujvPl8_dtiN3lXn7wcU,41650
-quantalogic-0.2.13.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.2.13.dist-info/entry_points.txt,sha256=wgSq5SRU98yvlRHGEZD1Xn7sS5CSjH2RfUtTa6Qy28Q,52
-quantalogic-0.2.13.dist-info/RECORD,,
+quantalogic-0.2.15.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.2.15.dist-info/METADATA,sha256=eIK_0Ll5qQfhvkqfVXCuuTmrwKzwC-_MVTrkZrDxNO4,41700
+quantalogic-0.2.15.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.2.15.dist-info/entry_points.txt,sha256=wgSq5SRU98yvlRHGEZD1Xn7sS5CSjH2RfUtTa6Qy28Q,52
+quantalogic-0.2.15.dist-info/RECORD,,