tree-sitter-analyzer 1.8.3__py3-none-any.whl → 1.9.0__py3-none-any.whl

tree_sitter_analyzer/queries/html.py

@@ -30,7 +30,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$"))) @void_element
     """,
-    
     # --- Attributes ---
     "attribute": """
     (attribute
@@ -67,7 +66,6 @@ HTML_QUERIES: dict[str, str] = {
         (#match? @attr_name "^href$")
         value: (quoted_attribute_value) @href_value) @href_attribute
     """,
-    
     # --- Text Content ---
     "text": """
     (text) @text
@@ -75,12 +73,10 @@ HTML_QUERIES: dict[str, str] = {
     "raw_text": """
     (raw_text) @raw_text
     """,
-    
     # --- Comments ---
     "comment": """
     (comment) @comment
     """,
-    
     # --- Document Structure ---
     "doctype": """
     (doctype) @doctype
@@ -88,7 +84,6 @@ HTML_QUERIES: dict[str, str] = {
     "document": """
     (document) @document
     """,
-    
     # --- Semantic Elements ---
     "heading": """
     (element
@@ -144,7 +139,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^(td|th)$"))) @table_cell
     """,
-    
     # --- Structure Elements ---
     "html": """
     (element
@@ -218,7 +212,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^span$"))) @span
     """,
-    
     # --- Form Elements ---
     "form": """
     (element
@@ -274,7 +267,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^legend$"))) @legend
     """,
-    
     # --- Media Elements ---
     "video": """
     (element
@@ -312,7 +304,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^svg$"))) @svg
     """,
-    
     # --- Meta Elements ---
     "meta": """
     (element
@@ -356,7 +347,6 @@ HTML_QUERIES: dict[str, str] = {
             name: (tag_name) @tag_name
             (#match? @tag_name "^base$"))) @base
     """,
-    
     # --- Script and Style Elements ---
     "script_element": """
     (script_element) @script_element
@@ -364,7 +354,6 @@ HTML_QUERIES: dict[str, str] = {
     "style_element": """
     (style_element) @style_element
     """,
-    
     # --- Name-only Extraction ---
     "tag_name": """
     (tag_name) @tag_name
@@ -507,9 +496,7 @@ def get_html_query(name: str) -> str:
     """
     if name not in HTML_QUERIES:
         available = list(HTML_QUERIES.keys())
-        raise ValueError(
-            f"HTML query '{name}' does not exist. Available: {available}"
-        )
+        raise ValueError(f"HTML query '{name}' does not exist. Available: {available}")
 
     return HTML_QUERIES[name]
 
@@ -553,4 +540,4 @@ def get_available_html_queries() -> list[str]:
     Returns:
         List of query names
     """
-    return list(HTML_QUERIES.keys())
+    return list(HTML_QUERIES.keys())

tree_sitter_analyzer/queries/markdown.py

@@ -6,100 +6,81 @@ Tree-sitter queries for extracting Markdown elements including headers,
 links, code blocks, lists, and other structural elements.
 """
 
-from typing import Dict, List
-
 # Markdown element extraction queries - simplified for compatibility
-MARKDOWN_QUERIES: Dict[str, str] = {
+MARKDOWN_QUERIES: dict[str, str] = {
     # Headers (H1-H6) - simplified
     "headers": """
     (atx_heading) @header
     (setext_heading) @header
     """,
-    
     # Code blocks - simplified
     "code_blocks": """
     (fenced_code_block) @code_block
     (indented_code_block) @code_block
     """,
-    
     # Inline code - simplified
     "inline_code": """
     (inline) @inline
     """,
-    
     # Links - simplified to avoid invalid node types
     "links": """
     (inline) @inline
     """,
-    
     # Images - simplified to avoid invalid node types
     "images": """
     (inline) @inline
     """,
-    
     # Lists - simplified to avoid invalid node types
     "lists": """
     (list) @list
     (list_item) @list_item
     """,
-    
     # Emphasis and strong - simplified
     "emphasis": """
     (inline) @inline
     """,
-    
     # Blockquotes - simplified
     "blockquotes": """
     (block_quote) @blockquote
     """,
-    
     # Tables - simplified
     "tables": """
     (pipe_table) @table
     """,
-    
     # Horizontal rules - simplified
     "horizontal_rules": """
     (thematic_break) @hr
     """,
-    
     # HTML blocks - simplified
     "html_blocks": """
     (html_block) @html_block
     """,
-    
     # Inline HTML - simplified
     "inline_html": """
     (inline) @inline
     """,
-    
     # Strikethrough - simplified
     "strikethrough": """
     (inline) @inline
     """,
-    
     # Task lists - simplified
     "task_lists": """
     (list_item) @list_item
     """,
-    
     # Footnotes - simplified
     "footnotes": """
     (paragraph) @paragraph
     (inline) @inline
     """,
-    
     # All text content - simplified
     "text_content": """
     (paragraph) @paragraph
     (inline) @inline
     """,
-    
     # Document structure - simplified
     "document": """
     (document) @document
     """,
-    
     # All elements (comprehensive) - simplified
     "all_elements": """
     (atx_heading) @heading
@@ -119,10 +100,10 @@ MARKDOWN_QUERIES: Dict[str, str] = {
 }
 
 # Query aliases for convenience
-QUERY_ALIASES: Dict[str, str] = {
+QUERY_ALIASES: dict[str, str] = {
     "heading": "headers",
     "h1": "headers",
-    "h2": "headers", 
+    "h2": "headers",
     "h3": "headers",
     "h4": "headers",
     "h5": "headers",
@@ -157,34 +138,36 @@ QUERY_ALIASES: Dict[str, str] = {
     "everything": "all_elements",
 }
 
+
 def get_query(query_name: str) -> str:
     """
     Get a query by name, supporting aliases
-    
+
     Args:
         query_name: Name of the query or alias
-        
+
     Returns:
         Query string
-        
+
     Raises:
         KeyError: If query name is not found
     """
     # Check direct queries first
     if query_name in MARKDOWN_QUERIES:
         return MARKDOWN_QUERIES[query_name]
-    
+
     # Check aliases
     if query_name in QUERY_ALIASES:
         actual_query = QUERY_ALIASES[query_name]
         return MARKDOWN_QUERIES[actual_query]
-    
+
     raise KeyError(f"Unknown query: {query_name}")
 
-def get_available_queries() -> List[str]:
+
+def get_available_queries() -> list[str]:
     """
     Get list of all available query names including aliases
-    
+
     Returns:
         List of query names
     """
@@ -192,31 +175,35 @@ def get_available_queries() -> List[str]:
     aliases = list(QUERY_ALIASES.keys())
     return sorted(queries + aliases)
 
-def get_query_info(query_name: str) -> Dict[str, str]:
+
+def get_query_info(query_name: str) -> dict[str, str]:
     """
     Get information about a query
-    
+
     Args:
         query_name: Name of the query
-        
+
     Returns:
         Dictionary with query information
     """
     try:
         query_string = get_query(query_name)
         is_alias = query_name in QUERY_ALIASES
-        actual_name = QUERY_ALIASES.get(query_name, query_name) if is_alias else query_name
-        
+        actual_name = (
+            QUERY_ALIASES.get(query_name, query_name) if is_alias else query_name
+        )
+
         return {
             "name": query_name,
             "actual_name": actual_name,
             "is_alias": is_alias,
             "query": query_string,
-            "description": _get_query_description(actual_name)
+            "description": _get_query_description(actual_name),
         }
     except KeyError:
         return {"error": f"Query '{query_name}' not found"}
 
+
 def _get_query_description(query_name: str) -> str:
     """Get description for a query"""
     descriptions = {
@@ -237,27 +224,29 @@ def _get_query_description(query_name: str) -> str:
         "footnotes": "Extract footnote references and definitions",
         "text_content": "Extract all text content",
         "document": "Extract document root",
-        "all_elements": "Extract all Markdown elements"
+        "all_elements": "Extract all Markdown elements",
     }
     return descriptions.get(query_name, "No description available")
 
+
 def get_all_queries() -> dict[str, str]:
     """
     Get all queries for the query loader
-    
+
     Returns:
         Dictionary mapping query names to query strings
     """
     # Combine direct queries and aliases
     all_queries = MARKDOWN_QUERIES.copy()
-    
+
     # Add aliases that point to actual queries
     for alias, target in QUERY_ALIASES.items():
         if target in MARKDOWN_QUERIES:
             all_queries[alias] = MARKDOWN_QUERIES[target]
-    
+
     return all_queries
 
+
 # Export main functions and constants
 __all__ = [
     "MARKDOWN_QUERIES",
@@ -265,5 +254,5 @@ __all__ = [
     "get_query",
     "get_available_queries",
     "get_query_info",
-    "get_all_queries"
-]
+    "get_all_queries",
+]

tree_sitter_analyzer/queries/python.py

@@ -726,10 +726,22 @@ ALL_QUERIES["functions"] = {
     "query": FUNCTIONS,
     "description": "Search all function definitions (including async)",
 }
-ALL_QUERIES["classes"] = {"query": CLASSES, "description": "Search all class definitions"}
-ALL_QUERIES["imports"] = {"query": IMPORTS, "description": "Search all import statements"}
-ALL_QUERIES["variables"] = {"query": VARIABLES, "description": "Search all variable assignments"}
-ALL_QUERIES["decorators"] = {"query": DECORATORS, "description": "Search all decorators"}
+ALL_QUERIES["classes"] = {
+    "query": CLASSES,
+    "description": "Search all class definitions",
+}
+ALL_QUERIES["imports"] = {
+    "query": IMPORTS,
+    "description": "Search all import statements",
+}
+ALL_QUERIES["variables"] = {
+    "query": VARIABLES,
+    "description": "Search all variable assignments",
+}
+ALL_QUERIES["decorators"] = {
+    "query": DECORATORS,
+    "description": "Search all decorators",
+}
 ALL_QUERIES["methods"] = {
     "query": METHODS,
     "description": "Search all method definitions within classes",
@@ -742,7 +754,10 @@ ALL_QUERIES["comprehensions"] = {
     "query": COMPREHENSIONS,
     "description": "Search list, dictionary, and set comprehensions",
 }
-ALL_QUERIES["comments"] = {"query": COMMENTS, "description": "Search comments and docstrings"}
+ALL_QUERIES["comments"] = {
+    "query": COMMENTS,
+    "description": "Search comments and docstrings",
+}
 ALL_QUERIES["type_hints"] = {
     "query": TYPE_HINTS,
     "description": "Search type hints and annotations",

tree_sitter_analyzer/query_loader.py

@@ -6,7 +6,7 @@ Optimized with enhanced caching and lazy loading for better performance.
 
 import importlib
 
-from .utils import log_error, log_warning
+from .utils import log_error
 
 
 class QueryLoader:
@@ -58,10 +58,10 @@ class QueryLoader:
         # Handle None or empty language - return empty dict without warning
         if not language or language == "None" or language.strip() == "":
             return {}
-            
+
         # Normalize language name
         language = language.strip().lower()
-            
+
         if language in self._failed_languages:
             return {}
 
@@ -108,7 +108,7 @@ class QueryLoader:
         # Handle invalid language early
         if not language or language == "None" or language.strip() == "":
             return None
-            
+
         queries = self.load_language_queries(language)
 
         if query_name in queries:
@@ -140,7 +140,7 @@ class QueryLoader:
         # Handle invalid language early
         if not language or language == "None" or language.strip() == "":
             return []
-            
+
         queries = self.load_language_queries(language)
         return list(queries.keys())