quantalogic 0.2.0__py3-none-any.whl

quantalogic/tools/language_handlers/scala_handler.py

@@ -0,0 +1,33 @@
+import tree_sitter_scala as tsscala
+from tree_sitter import Language
+
+
+class ScalaLanguageHandler:
+    """Handler for Scala-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for Scala."""
+        return Language(tsscala.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for Scala syntax trees."""
+        return root_node.type == "compilation_unit"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a Scala syntax tree."""
+        if node.type in ("function_definition", "method_definition"):
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "class_definition":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"

quantalogic/tools/language_handlers/typescript_handler.py

@@ -0,0 +1,42 @@
+import tree_sitter_typescript as tstypescript
+from tree_sitter import Language
+
+
+class TypeScriptLanguageHandler:
+    """Handler for TypeScript-specific language processing."""
+
+    def get_language(self):
+        """Returns the Tree-sitter Language object for TypeScript."""
+        return Language(tstypescript.language())
+
+    def validate_root_node(self, root_node):
+        """Validates the root node for TypeScript syntax trees."""
+        return root_node.type == "program"
+
+    def process_node(
+        self, node, current_class, definitions, process_method, process_function, process_class, process_class_variable
+    ):
+        """Processes a node in a TypeScript syntax tree."""
+        if node.type in ("function_declaration", "method_definition"):
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            else:
+                process_function(node, definitions["functions"])
+            return "function"
+        elif node.type == "class_declaration":
+            class_name = process_class(node)
+            definitions["classes"][class_name] = {
+                "line": (node.start_point[0] + 1, node.end_point[0] + 1),
+                "methods": [],
+                "variables": [],
+            }
+            return "class"
+        elif node.type == "method_definition":
+            if current_class:
+                process_method(node, definitions["classes"][current_class]["methods"])
+            return "method"
+        elif node.type == "class_variable_definition":
+            if current_class:
+                process_class_variable(node, definitions["classes"][current_class]["variables"])
+            return "variable"
+        return None

quantalogic/tools/list_directory_tool.py

@@ -0,0 +1,123 @@
+"""Tool for listing the contents of a directory."""
+
+import os
+
+from quantalogic.tools.tool import Tool, ToolArgument
+from quantalogic.utils.git_ls import git_ls
+
+
+class ListDirectoryTool(Tool):
+    """Lists directory contents with pagination and .gitignore support."""
+
+    name: str = "list_directory_tool"
+    description: str = "Lists directory contents with pagination and .gitignore filtering"
+    arguments: list[ToolArgument] = [
+        ToolArgument(
+            name="directory_path",
+            arg_type="string",
+            description="Absolute or relative path to target directory",
+            required=True,
+            example="~/documents/projects",
+        ),
+        ToolArgument(
+            name="recursive",
+            arg_type="string",
+            description="Enable recursive traversal (true/false)",
+            required=False,
+            default="false",
+            example="true",
+        ),
+        ToolArgument(
+            name="max_depth",
+            arg_type="int",
+            description="Maximum directory traversal depth",
+            required=False,
+            default="1",
+            example="1",
+        ),
+        ToolArgument(
+            name="start_line",
+            arg_type="int",
+            description="First line to return in paginated results",
+            required=False,
+            default="1",
+            example="1",
+        ),
+        ToolArgument(
+            name="end_line",
+            arg_type="int",
+            description="Last line to return in paginated results",
+            required=False,
+            default="200",
+            example="200",
+        ),
+    ]
+
+    def execute(
+        self,
+        directory_path: str,
+        recursive: str = "false",
+        max_depth: str = "1",
+        start_line: str = "1",
+        end_line: str = "200",
+    ) -> str:
+        """
+        List directory contents with pagination and .gitignore support.
+
+        Args:
+            directory_path: Absolute or relative path to target directory
+            recursive: Enable recursive traversal (true/false)
+            max_depth: Maximum directory traversal depth
+            start_line: First line to return in paginated results
+            end_line: Last line to return in paginated results
+
+        Returns:
+            str: Paginated directory listing with metadata
+
+        Raises:
+            ValueError: For invalid directory paths or pagination parameters
+        """
+        # Expand user home directory to full path
+        # This ensures compatibility with '~' shorthand for home directory
+        if directory_path.startswith("~"):
+            directory_path = os.path.expanduser(directory_path)
+
+        # Validate directory existence and type
+        # Fail early with clear error messages if path is invalid
+        if not os.path.exists(directory_path):
+            raise ValueError(f"The directory '{directory_path}' does not exist.")
+        if not os.path.isdir(directory_path):
+            raise ValueError(f"The path '{directory_path}' is not a directory.")
+
+        # Safely convert inputs with default values
+        start = int(start_line or "1")
+        end = int(end_line or "200")
+        max_depth_int = int(max_depth or "1")
+        is_recursive = (recursive or "false").lower() == "true"
+
+        # Validate pagination parameters
+        if start > end:
+            raise ValueError("start_line must be less than or equal to end_line.")
+
+        try:
+            # Use git_ls for directory listing with .gitignore support
+            all_lines = git_ls(
+                directory_path=directory_path,
+                recursive=is_recursive,
+                max_depth=max_depth_int,
+                start_line=start,
+                end_line=end,
+            )
+            return all_lines
+        except Exception as e:
+            import traceback
+
+            traceback.print_exc()
+            return f"Error: {str(e)} occurred during directory listing. See logs for details."
+
+
+if __name__ == "__main__":
+    tool = ListDirectoryTool()
+    current_directory = os.getcwd()
+    tool.execute(directory_path=current_directory, recursive="true")
+    print(tool.to_markdown())

quantalogic/tools/llm_tool.py

@@ -0,0 +1,119 @@
+"""LLM Tool for generating answers to questions using a language model."""
+
+import logging
+
+from pydantic import ConfigDict, Field
+
+from quantalogic.generative_model import GenerativeModel, Message
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class LLMTool(Tool):
+    """Tool to generate answers using a specified language model."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    name: str = Field(default="llm_tool")
+    description: str = Field(
+        default=(
+            "Generates answers to questions using a specified language model. "
+            "Note: This tool operates in isolation and does not have access to: "
+            " - Memory: All context must be explicitly provided in the prompt. "
+            " - File system."
+            " - Variables: Any required variables should be interpolated into the prompt (e.g., $var1$). "
+            " - Other tools: It cannot invoke or interact with other tools. "
+            "Ensure all necessary information is included directly in your prompt."
+        )
+    )
+    arguments: list = Field(
+        default=[
+            ToolArgument(
+                name="system_prompt",
+                arg_type="string",
+                description=("The persona or system prompt to guide the language model's behavior. "),
+                required=True,
+                example=("You are an expert in natural language processing and machine learning. "),
+            ),
+            ToolArgument(
+                name="prompt",
+                arg_type="string",
+                description=("The question to ask the language model. Use interpolation if possible example $var1$."),
+                required=True,
+                example="What is the meaning of $var1$ ?",
+            ),
+            ToolArgument(
+                name="temperature",
+                arg_type="string",
+                description='Sampling temperature between "0.0" and "1.0": "0.0" no creativity, "1.0" full creativity. (float)',
+                required=True,
+                default="0.5",
+                example="0.5",
+            ),
+        ]
+    )
+
+    model_name: str = Field(..., description="The name of the language model to use")
+    generative_model: GenerativeModel | None = Field(default=None)
+
+    def model_post_init(self, __context):
+        """Initialize the generative model after model initialization."""
+        if self.generative_model is None:
+            self.generative_model = GenerativeModel(model=self.model_name)
+            logging.debug(f"Initialized LLMTool with model: {self.model_name}")
+
+    def execute(self, system_prompt: str, prompt: str, temperature: str = "0.7") -> str:
+        """Execute the tool to generate an answer based on the provided question.
+
+        Args:
+            system_prompt (str): The system prompt to guide the model.
+            prompt (str): The question to be answered.
+            temperature (str, optional): Sampling temperature. Defaults to "0.7".
+
+        Returns:
+            str: The generated answer.
+
+        Raises:
+            ValueError: If temperature is not a valid float between 0 and 1.
+            Exception: If there's an error during response generation.
+        """
+        try:
+            temp = float(temperature)
+            if not (0.0 <= temp <= 1.0):
+                raise ValueError("Temperature must be between 0 and 1.")
+        except ValueError as ve:
+            logging.error(f"Invalid temperature value: {temperature}")
+            raise ValueError(f"Invalid temperature value: {temperature}") from ve
+
+        # Prepare the messages history
+        messages_history = [
+            Message(role="system", content=system_prompt),
+            Message(role="user", content=prompt),
+        ]
+
+        # Set the model's temperature
+        if self.generative_model:
+            self.generative_model.temperature = temp
+
+            # Generate the response using the generative model
+            try:
+                response_stats = self.generative_model.generate_with_history(
+                    messages_history=messages_history, prompt=""
+                )
+                response = response_stats.response.strip()
+                logging.info(f"Generated response: {response}")
+                return response
+            except Exception as e:
+                logging.error(f"Error generating response: {e}")
+                raise Exception(f"Error generating response: {e}") from e
+        else:
+            raise ValueError("Generative model not initialized")
+
+
+if __name__ == "__main__":
+    # Example usage of LLMTool
+    tool = LLMTool(model_name="gpt-4o-mini")
+    system_prompt = 'Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the context, say "I don\'t know".'
+    question = "What is the meaning of life?"
+    temperature = "0.7"
+    answer = tool.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
+    print(answer)

quantalogic/tools/markitdown_tool.py

@@ -0,0 +1,105 @@
+"""Tool for converting various file formats to Markdown using the MarkItDown library."""
+
+import os
+import tempfile
+from typing import Optional
+
+from quantalogic.tools.tool import Tool, ToolArgument
+from quantalogic.utils.download_http_file import download_http_file
+
+MAX_LINES = 2000  # Maximum number of lines to return when no output file is specified
+
+
+class MarkitdownTool(Tool):
+    """Tool for converting various file formats to Markdown using the MarkItDown library."""
+
+    name: str = "markitdown_tool"
+    description: str = (
+        "Converts various file formats to Markdown using the MarkItDown library. "
+        "Supports both local file paths and URLs (http://, https://). "
+        "Supported formats include: PDF, PowerPoint, Word, Excel, HTML"
+        "Don't use the output_file_path argument if you want to return the result in markdown directly"
+    )
+    arguments: list = [
+        ToolArgument(
+            name="file_path",
+            arg_type="string",
+            description="The path to the file to convert. Can be a local path or URL (http://, https://).",
+            required=True,
+            example="/path/to/file.txt or https://example.com/file.pdf",
+        ),
+        ToolArgument(
+            name="output_file_path",
+            arg_type="string",
+            description="Path to write the Markdown output to. You can use a temp file.",
+            required=False,
+            example="/path/to/output.md",
+        ),
+    ]
+
+    def execute(self, file_path: str, output_file_path: Optional[str] = None) -> str:
+        """Converts a file to Markdown and returns or writes the content.
+
+        Args:
+            file_path (str): The path to the file to convert. Can be a local path or URL.
+            output_file_path (str, optional): Optional path to write the Markdown output to.
+
+        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
+
+            md = MarkItDown()
+            result = md.convert(file_path)
+
+            if output_file_path:
+                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
+        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)
+
+
+if __name__ == "__main__":
+    tool = MarkitdownTool()
+    print(tool.to_markdown())
+
+    # Example usage:
+    print(tool.execute(file_path="./examples/2412.18601v1.pdf"))
+
+    print(tool.execute(file_path="https://arxiv.org/pdf/2412.18601"))