tree-sitter-analyzer 0.3.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

tree_sitter_analyzer/output_manager.py

@@ -86,22 +86,22 @@ class OutputManager:
                 f"\n{index}. {result.get('capture_name', 'Unknown')} ({result.get('node_type', 'Unknown')})"
             )
             print(
-                f"   位置: 行 {result.get('start_line', '?')}-{result.get('end_line', '?')}"
+                f"   Position: Line {result.get('start_line', '?')}-{result.get('end_line', '?')}"
             )
             if "content" in result:
-                print(f"   内容:\n{result['content']}")
+                print(f"   Content:\n{result['content']}")
 
     def analysis_summary(self, stats: dict[str, Any]) -> None:
         """Output analysis summary"""
         if self.json_output:
             self.data(stats)
         else:
-            self.results_header("統計情報")
+            self.results_header("Statistics")
             for key, value in stats.items():
                 print(f"{key}: {value}")
 
     def language_list(
-        self, languages: list[str], title: str = "サポートされている言語"
+        self, languages: list[str], title: str = "Supported Languages"
     ) -> None:
         """Output language list"""
         if not self.quiet:
@@ -112,18 +112,18 @@ class OutputManager:
     def query_list(self, queries: dict[str, str], language: str) -> None:
         """Output query list for a language"""
         if not self.quiet:
-            print(f"利用可能なクエリキー ({language}):")
+            print(f"Available query keys ({language}):")
             for query_key, description in queries.items():
                 print(f"  {query_key:<20} - {description}")
 
     def extension_list(self, extensions: list[str]) -> None:
         """Output supported extensions"""
         if not self.quiet:
-            print("サポートされている拡張子:")
+            print("Supported file extensions:")
             for i in range(0, len(extensions), 10):
                 chunk = extensions[i : i + 10]
                 print(f"  {' '.join(chunk)}")
-            print(f"合計 {len(extensions)} 個の拡張子をサポート")
+            print(f"Total {len(extensions)} extensions supported")
 
     def output_json(self, data: Any) -> None:
         """Output JSON data"""
@@ -159,11 +159,8 @@ class OutputManager:
 
     def output_queries(self, queries: list[str]) -> None:
         """Output available queries"""
-        if isinstance(queries, list):
-            query_dict = {q: f"Query {q}" for q in queries}
-            self.query_list(query_dict, "All")
-        else:
-            self.query_list(queries, "All")
+        query_dict = {q: f"Query {q}" for q in queries}
+        self.query_list(query_dict, "All")
 
     def output_extensions(self, extensions: list[str]) -> None:
         """Output file extensions"""
@@ -235,20 +232,15 @@ def output_statistics(stats: dict[str, Any]) -> None:
     _output_manager.output_statistics(stats)
 
 
-def output_languages(
-    languages: list[str], title: str = "サポートされている言語"
-) -> None:
+def output_languages(languages: list[str], title: str = "Supported Languages") -> None:
     """Output available languages"""
     _output_manager.language_list(languages, title)
 
 
 def output_queries(queries: list[str], language: str = "All") -> None:
     """Output available queries"""
-    if isinstance(queries, list):
-        query_dict = {q: f"Query {q}" for q in queries}
-        _output_manager.query_list(query_dict, language)
-    else:
-        _output_manager.query_list(queries, language)
+    query_dict = {q: f"Query {q}" for q in queries}
+    _output_manager.query_list(query_dict, language)
 
 
 def output_extensions(extensions: list[str]) -> None:

tree_sitter_analyzer/plugins/__init__.py

@@ -21,7 +21,12 @@ from ..models import Import as ModelImport
 from ..models import Variable as ModelVariable
 from ..utils import log_debug, log_error, log_warning
 
-__all__ = ["LanguagePlugin", "ElementExtractor", "PluginRegistry", "plugin_registry"]
+__all__ = [
+    "LanguagePlugin",
+    "ElementExtractor",
+    "DefaultExtractor",
+    "DefaultLanguagePlugin",
+]
 
 
 class ElementExtractor(ABC):
@@ -255,50 +260,7 @@ class DefaultExtractor(ElementExtractor):
             return None
 
 
-class PluginRegistry:
-    """Registry for managing language plugins"""
-
-    def __init__(self) -> None:
-        self._plugins: dict[str, LanguagePlugin] = {}
-        self._extension_map: dict[str, LanguagePlugin] = {}
-        self._default_plugin = DefaultLanguagePlugin()
-
-    def register_plugin(self, plugin: LanguagePlugin) -> None:
-        """Register a language plugin"""
-        try:
-            language = plugin.get_language_name()
-            self._plugins[language] = plugin
-
-            # Register file extensions
-            for ext in plugin.get_file_extensions():
-                self._extension_map[ext] = plugin
-
-            log_debug(f"Registered plugin for language: {language}")
-        except Exception as e:
-            log_error(f"Failed to register plugin: {e}")
-
-    def get_plugin(self, language: str) -> LanguagePlugin | None:
-        """Get plugin for specified language"""
-        return self._plugins.get(language)
-
-    def get_plugin_by_extension(self, extension: str) -> LanguagePlugin | None:
-        """Get plugin for specified file extension"""
-        return self._extension_map.get(extension)
-
-    def get_plugin_for_file(self, file_path: str) -> LanguagePlugin:
-        """Get appropriate plugin for a file"""
-        for plugin in self._plugins.values():
-            if plugin.is_applicable(file_path):
-                return plugin
-        return self._default_plugin
-
-    def list_supported_languages(self) -> list[str]:
-        """List all supported languages"""
-        return list(self._plugins.keys())
-
-    def list_supported_extensions(self) -> list[str]:
-        """List all supported file extensions"""
-        return list(self._extension_map.keys())
+# Legacy PluginRegistry removed - now using PluginManager from .manager
 
 
 class DefaultLanguagePlugin(LanguagePlugin):
@@ -314,20 +276,5 @@ class DefaultLanguagePlugin(LanguagePlugin):
         return DefaultExtractor()
 
 
-# Global plugin registry instance
-plugin_registry = PluginRegistry()
-
-
-# Auto-load all plugins when the package is imported
-try:
-    # from .plugin_loader import (
-    #     get_supported_extensions,  # Not used currently
-    #     get_supported_languages,  # Not used currently
-    #     load_all_plugins,  # Not used currently
-    # )
-    pass
-    # Plugins are automatically loaded when plugin_loader is imported
-except ImportError as e:
-    from ..utils import log_warning
-
-    log_warning(f"Could not load plugin loader: {e}")
+# Legacy plugin registry removed - now using PluginManager
+# from .manager import PluginManager

tree_sitter_analyzer/plugins/base.py

@@ -13,6 +13,9 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     import tree_sitter
 
+    from ..core.analysis_engine import AnalysisRequest
+    from ..models import AnalysisResult
+
 from ..models import Class as ModelClass
 from ..models import CodeElement
 from ..models import Function as ModelFunction
@@ -108,7 +111,7 @@ class ElementExtractor(ABC):
         Returns:
             List of all extracted code elements
         """
-        elements = []
+        elements: list[CodeElement] = []
 
         try:
             elements.extend(self.extract_functions(tree, source_code))
@@ -159,6 +162,22 @@ class LanguagePlugin(ABC):
         """
         pass
 
+    @abstractmethod
+    async def analyze_file(
+        self, file_path: str, request: "AnalysisRequest"
+    ) -> "AnalysisResult":
+        """
+        Analyze a file and return analysis results.
+
+        Args:
+            file_path: Path to the file to analyze
+            request: Analysis request with configuration
+
+        Returns:
+            AnalysisResult containing extracted information
+        """
+        pass
+
     def is_applicable(self, file_path: str) -> bool:
         """
         Check if this plugin is applicable for the given file.
@@ -475,3 +494,36 @@ class DefaultLanguagePlugin(LanguagePlugin):
 
     def create_extractor(self) -> ElementExtractor:
         return DefaultExtractor()
+
+    async def analyze_file(
+        self, file_path: str, request: "AnalysisRequest"
+    ) -> "AnalysisResult":
+        """
+        Analyze a file using the default extractor.
+
+        Args:
+            file_path: Path to the file to analyze
+            request: Analysis request with configuration
+
+        Returns:
+            AnalysisResult containing extracted information
+        """
+        from ..core.analysis_engine import UnifiedAnalysisEngine
+        from ..models import AnalysisResult
+
+        try:
+            engine = UnifiedAnalysisEngine()
+            return await engine.analyze_file(file_path)
+        except Exception as e:
+            log_error(f"Failed to analyze file {file_path}: {e}")
+            return AnalysisResult(
+                file_path=file_path,
+                language=self.get_language_name(),
+                line_count=0,
+                elements=[],
+                node_count=0,
+                query_results={},
+                source_code="",
+                success=False,
+                error_message=str(e),
+            )

tree_sitter_analyzer/plugins/manager.py

@@ -11,6 +11,7 @@ import importlib.metadata
 import logging
 import pkgutil
 from pathlib import Path
+from typing import Any
 
 from ..utils import log_debug, log_error, log_info, log_warning
 from .base import LanguagePlugin
@@ -29,7 +30,7 @@ class PluginManager:
     - Error handling and fallback mechanisms
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the plugin manager."""
         self._loaded_plugins: dict[str, LanguagePlugin] = {}
         self._plugin_classes: dict[str, type[LanguagePlugin]] = {}
@@ -52,13 +53,19 @@ class PluginManager:
         local_plugins = self._load_from_local_directory()
         loaded_plugins.extend(local_plugins)
 
-        # Store loaded plugins
+        # Store loaded plugins and deduplicate by language
+        unique_plugins = {}
         for plugin in loaded_plugins:
             language = plugin.get_language_name()
-            self._loaded_plugins[language] = plugin
+            if language not in unique_plugins:
+                unique_plugins[language] = plugin
+                self._loaded_plugins[language] = plugin
+            else:
+                log_debug(f"Skipping duplicate plugin for language: {language}")
 
-        log_info(f"Successfully loaded {len(loaded_plugins)} plugins")
-        return loaded_plugins
+        final_plugins = list(unique_plugins.values())
+        log_info(f"Successfully loaded {len(final_plugins)} plugins")
+        return final_plugins
 
     def _load_from_entry_points(self) -> list[LanguagePlugin]:
         """
@@ -74,12 +81,22 @@ class PluginManager:
             entry_points = importlib.metadata.entry_points()
 
             # Handle both old and new entry_points API
+            plugin_entries: Any = []
             if hasattr(entry_points, "select"):
                 # New API (Python 3.10+)
                 plugin_entries = entry_points.select(group=self._entry_point_group)
             else:
-                # Old API
-                plugin_entries = entry_points.get(self._entry_point_group, [])
+                # Old API - handle different return types
+                try:
+                    # Try to get entry points, handling different API versions
+                    if hasattr(entry_points, "get"):
+                        result = entry_points.get(self._entry_point_group)
+                        plugin_entries = list(result) if result else []
+                    else:
+                        plugin_entries = []
+                except (TypeError, AttributeError):
+                    # Fallback for incompatible entry_points types
+                    plugin_entries = []
 
             for entry_point in plugin_entries:
                 try:
@@ -116,7 +133,7 @@ class PluginManager:
         Returns:
             List of plugin instances loaded from local directory
         """
-        plugins = []
+        plugins: list[LanguagePlugin] = []
 
         try:
             # Get the languages directory path
@@ -171,7 +188,7 @@ class PluginManager:
 
         return plugins
 
-    def _find_plugin_classes(self, module) -> list[type[LanguagePlugin]]:
+    def _find_plugin_classes(self, module: Any) -> list[type[LanguagePlugin]]:
         """
         Find LanguagePlugin classes in a module.
 
@@ -181,7 +198,7 @@ class PluginManager:
         Returns:
             List of LanguagePlugin classes found in the module
         """
-        plugin_classes = []
+        plugin_classes: list[type[LanguagePlugin]] = []
 
         for attr_name in dir(module):
             attr = getattr(module, attr_name)
@@ -285,7 +302,7 @@ class PluginManager:
 
         return False
 
-    def get_plugin_info(self, language: str) -> dict[str, any] | None:
+    def get_plugin_info(self, language: str) -> dict[str, Any] | None:
         """
         Get information about a specific plugin.
 
@@ -347,7 +364,7 @@ class PluginManager:
 
             extensions = plugin.get_file_extensions()
             if not isinstance(extensions, list):
-                log_error("Plugin get_file_extensions() must return a list")
+                log_error("Plugin get_file_extensions() must return a list")  # type: ignore[unreachable]
                 return False
 
             extractor = plugin.create_extractor()

tree_sitter_analyzer/queries/java.py

@@ -6,9 +6,9 @@ Tree-sitter queries specific to Java language constructs.
 Covers classes, methods, annotations, imports, and other Java-specific elements.
 """
 
-# Java専用クエリライブラリ
+# Java-specific query library
 JAVA_QUERIES: dict[str, str] = {
-    # --- 基本構造 ---
+    # --- Basic Structure ---
     "class": """
     (class_declaration) @class
     """,
@@ -21,7 +21,7 @@ JAVA_QUERIES: dict[str, str] = {
     "annotation_type": """
     (annotation_type_declaration) @annotation_type
     """,
-    # --- メソッドと構築子 ---
+    # --- Methods and Constructors ---
     "method": """
     (method_declaration) @method
     """,
@@ -33,7 +33,7 @@ JAVA_QUERIES: dict[str, str] = {
       (modifiers) @mod
       (#match? @mod "abstract")) @abstract_method
     """,
-    # --- フィールドと変数 ---
+    # --- Fields and Variables ---
     "field": """
     (field_declaration) @field
     """,
@@ -47,7 +47,7 @@ JAVA_QUERIES: dict[str, str] = {
       (modifiers) @mod
       (#match? @mod "final")) @final_field
     """,
-    # --- インポートとパッケージ ---
+    # --- Imports and Packages ---
     "import": """
     (import_declaration) @import
     """,
@@ -58,7 +58,7 @@ JAVA_QUERIES: dict[str, str] = {
     "package": """
     (package_declaration) @package
     """,
-    # --- アノテーション ---
+    # --- Annotations ---
     "annotation": """
     (annotation) @annotation
     """,
@@ -69,7 +69,7 @@ JAVA_QUERIES: dict[str, str] = {
     (annotation
       (annotation_argument_list)) @annotation_with_params
     """,
-    # --- Java特有のコンストラクト ---
+    # --- Java-specific Constructs ---
     "lambda": """
     (lambda_expression) @lambda
     """,
@@ -82,7 +82,7 @@ JAVA_QUERIES: dict[str, str] = {
     "generic_type": """
     (generic_type) @generic_type
     """,
-    # --- 名前のみ抽出 ---
+    # --- Name-only Extraction ---
     "class_name": """
     (class_declaration
       name: (identifier) @class_name)
@@ -96,7 +96,7 @@ JAVA_QUERIES: dict[str, str] = {
       declarator: (variable_declarator
         name: (identifier) @field_name))
     """,
-    # --- 詳細付きクエリ ---
+    # --- Detailed Queries ---
     "class_with_body": """
     (class_declaration
       name: (identifier) @name
@@ -112,7 +112,7 @@ JAVA_QUERIES: dict[str, str] = {
       (modifiers (annotation) @annotation)*
       name: (identifier) @name) @method_with_annotations
     """,
-    # --- 継承関係 ---
+    # --- Inheritance Relations ---
     "extends_clause": """
     (class_declaration
       (superclass) @extends_clause)
@@ -121,7 +121,7 @@ JAVA_QUERIES: dict[str, str] = {
     (class_declaration
       (super_interfaces) @implements_clause)
     """,
-    # --- 修飾子別 ---
+    # --- By Modifiers ---
     "public_methods": """
     (method_declaration
       (modifiers) @mod
@@ -140,7 +140,7 @@ JAVA_QUERIES: dict[str, str] = {
       (#match? @mod "static")
       name: (identifier) @name) @static_methods
     """,
-    # --- Spring Framework アノテーション ---
+    # --- Spring Framework Annotations ---
     "spring_controller": """
     (class_declaration
       (modifiers (annotation
@@ -162,7 +162,7 @@ JAVA_QUERIES: dict[str, str] = {
         (#match? @annotation_name "Repository")))
       name: (identifier) @repository_name) @spring_repository
     """,
-    # --- JPA アノテーション ---
+    # --- JPA Annotations ---
     "jpa_entity": """
     (class_declaration
       (modifiers (annotation
@@ -178,7 +178,7 @@ JAVA_QUERIES: dict[str, str] = {
       declarator: (variable_declarator
         name: (identifier) @field_name)) @jpa_id_field
     """,
-    # --- 構造情報抽出用クエリ ---
+    # --- Structural Information Extraction Queries ---
     "javadoc_comment": """
     (block_comment) @javadoc_comment
     (#match? @javadoc_comment "^/\\*\\*")
@@ -257,108 +257,108 @@ JAVA_QUERIES: dict[str, str] = {
     """,
 }
 
-# クエリの説明
+# Query descriptions
 JAVA_QUERY_DESCRIPTIONS: dict[str, str] = {
-    "class": "Javaクラス宣言を抽出",
-    "interface": "Javaインターフェース宣言を抽出",
-    "enum": "Java列挙型宣言を抽出",
-    "annotation_type": "Javaアノテーション型宣言を抽出",
-    "method": "Javaメソッド宣言を抽出",
-    "constructor": "Javaコンストラクタ宣言を抽出",
-    "field": "Javaフィールド宣言を抽出",
-    "import": "Javaインポート文を抽出",
-    "package": "Javaパッケージ宣言を抽出",
-    "annotation": "Javaアノテーションを抽出",
-    "lambda": "Javaラムダ式を抽出",
-    "try_catch": "Java try-catch文を抽出",
-    "class_name": "クラス名のみを抽出",
-    "method_name": "メソッド名のみを抽出",
-    "field_name": "フィールド名のみを抽出",
-    "class_with_body": "クラス宣言と本体を抽出",
-    "method_with_body": "メソッド宣言と本体を抽出",
-    "extends_clause": "クラスの継承句を抽出",
-    "implements_clause": "クラスの実装句を抽出",
-    "public_methods": "publicメソッドを抽出",
-    "private_methods": "privateメソッドを抽出",
-    "static_methods": "staticメソッドを抽出",
-    # 構造情報抽出用クエリの説明
-    "javadoc_comment": "JavaDocコメントを抽出",
-    "class_with_javadoc": "JavaDoc付きクラスを抽出",
-    "method_with_javadoc": "JavaDoc付きメソッドを抽出",
-    "field_with_javadoc": "JavaDoc付きフィールドを抽出",
-    "method_parameters_detailed": "メソッドパラメータの詳細情報を抽出",
-    "class_inheritance_detailed": "クラスの継承関係詳細を抽出",
-    "annotation_detailed": "アノテーションの詳細情報を抽出",
-    "import_detailed": "インポート文の詳細情報を抽出",
-    "package_detailed": "パッケージ宣言の詳細情報を抽出",
-    "constructor_detailed": "コンストラクタの詳細情報を抽出",
-    "enum_constant": "列挙型定数を抽出",
-    "interface_method": "インターフェースメソッドを抽出",
-    "spring_controller": "Spring Controllerクラスを抽出",
-    "spring_service": "Spring Serviceクラスを抽出",
-    "spring_repository": "Spring Repositoryクラスを抽出",
-    "jpa_entity": "JPA Entityクラスを抽出",
-    "abstract_method": "抽象メソッドを抽出",
-    "static_field": "静的フィールドを抽出",
-    "final_field": "finalフィールドを抽出",
-    "static_import": "静的インポート文を抽出",
-    "marker_annotation": "マーカーアノテーションを抽出",
-    "annotation_with_params": "パラメータ付きアノテーションを抽出",
-    "synchronized_block": "synchronized文を抽出",
-    "generic_type": "ジェネリック型を抽出",
-    "method_with_annotations": "アノテーション付きメソッドを抽出",
-    "jpa_id_field": "JPA IDフィールドを抽出",
+    "class": "Extract Java class declarations",
+    "interface": "Extract Java interface declarations",
+    "enum": "Extract Java enum declarations",
+    "annotation_type": "Extract Java annotation type declarations",
+    "method": "Extract Java method declarations",
+    "constructor": "Extract Java constructor declarations",
+    "field": "Extract Java field declarations",
+    "import": "Extract Java import statements",
+    "package": "Extract Java package declarations",
+    "annotation": "Extract Java annotations",
+    "lambda": "Extract Java lambda expressions",
+    "try_catch": "Extract Java try-catch statements",
+    "class_name": "Extract class names only",
+    "method_name": "Extract method names only",
+    "field_name": "Extract field names only",
+    "class_with_body": "Extract class declarations with body",
+    "method_with_body": "Extract method declarations with body",
+    "extends_clause": "Extract class inheritance clauses",
+    "implements_clause": "Extract class implementation clauses",
+    "public_methods": "Extract public methods",
+    "private_methods": "Extract private methods",
+    "static_methods": "Extract static methods",
+    # Structural information extraction query descriptions
+    "javadoc_comment": "Extract JavaDoc comments",
+    "class_with_javadoc": "Extract classes with JavaDoc",
+    "method_with_javadoc": "Extract methods with JavaDoc",
+    "field_with_javadoc": "Extract fields with JavaDoc",
+    "method_parameters_detailed": "Extract detailed method parameter information",
+    "class_inheritance_detailed": "Extract detailed class inheritance relationships",
+    "annotation_detailed": "Extract detailed annotation information",
+    "import_detailed": "Extract detailed import statement information",
+    "package_detailed": "Extract detailed package declaration information",
+    "constructor_detailed": "Extract detailed constructor information",
+    "enum_constant": "Extract enum constants",
+    "interface_method": "Extract interface methods",
+    "spring_controller": "Extract Spring Controller classes",
+    "spring_service": "Extract Spring Service classes",
+    "spring_repository": "Extract Spring Repository classes",
+    "jpa_entity": "Extract JPA Entity classes",
+    "abstract_method": "Extract abstract methods",
+    "static_field": "Extract static fields",
+    "final_field": "Extract final fields",
+    "static_import": "Extract static import statements",
+    "marker_annotation": "Extract marker annotations",
+    "annotation_with_params": "Extract annotations with parameters",
+    "synchronized_block": "Extract synchronized statements",
+    "generic_type": "Extract generic types",
+    "method_with_annotations": "Extract methods with annotations",
+    "jpa_id_field": "Extract JPA ID fields",
 }
 
 
 def get_java_query(name: str) -> str:
     """
-    指定されたJavaクエリを取得
+    Get the specified Java query
 
     Args:
-        name: クエリ名
+        name: Query name
 
     Returns:
-        クエリ文字列
+        Query string
 
     Raises:
-        ValueError: クエリが見つからない場合
+        ValueError: When query is not found
     """
     if name not in JAVA_QUERIES:
         available = list(JAVA_QUERIES.keys())
-        raise ValueError(f"Javaクエリ '{name}' は存在しません。利用可能: {available}")
+        raise ValueError(f"Java query '{name}' does not exist. Available: {available}")
 
     return JAVA_QUERIES[name]
 
 
 def get_java_query_description(name: str) -> str:
     """
-    指定されたJavaクエリの説明を取得
+    Get the description of the specified Java query
 
     Args:
-        name: クエリ名
+        name: Query name
 
     Returns:
-        クエリの説明
+        Query description
     """
-    return JAVA_QUERY_DESCRIPTIONS.get(name, "説明なし")
+    return JAVA_QUERY_DESCRIPTIONS.get(name, "No description")
 
 
 # Convert to ALL_QUERIES format for dynamic loader compatibility
 ALL_QUERIES = {}
 for query_name, query_string in JAVA_QUERIES.items():
-    description = JAVA_QUERY_DESCRIPTIONS.get(query_name, "説明なし")
+    description = JAVA_QUERY_DESCRIPTIONS.get(query_name, "No description")
     ALL_QUERIES[query_name] = {"query": query_string, "description": description}
 
 # Add common query aliases for cross-language compatibility
 ALL_QUERIES["functions"] = {
     "query": JAVA_QUERIES["method"],
-    "description": "すべての関数/メソッド宣言を検索（methodのエイリアス）",
+    "description": "Search all function/method declarations (alias for method)",
 }
 
 ALL_QUERIES["classes"] = {
     "query": JAVA_QUERIES["class"],
-    "description": "すべてのクラス宣言を検索（classのエイリアス）",
+    "description": "Search all class declarations (alias for class)",
 }
 
 
@@ -383,9 +383,9 @@ def list_queries() -> list:
 
 def get_available_java_queries() -> list[str]:
     """
-    利用可能なJavaクエリ一覧を取得
+    Get list of available Java queries
 
     Returns:
-        クエリ名のリスト
+        List of query names
     """
     return list(JAVA_QUERIES.keys())