Moved plugins and add loaded file filtering

- Moved prettify_json and lsp_completer plugins to sub categories
- Add filter_out_loaded_files to prevent opening already-loaded files
- Refactor code events into single events module
- Fix signal blocking during file load operations
- Include READONLY state in source view lifecycle handling

plugins/code/ui/lsp_manager/provider_response_cache.py

@@ -0,0 +1,114 @@
+# Python imports
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+from asyncio import Queue
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GtkSource
+
+# Application imports
+from libs.dto.code.lsp.lsp_message_structs import LSPResponseTypes, LSPResponseRequest, LSPResponseNotification
+
+from core.widgets.code.completion_providers.provider_response_cache_base import ProviderResponseCacheBase
+
+from .controllers.lsp_controller import LSPController
+from .mixins.lsp_client_events_mixin import LSPClientEventsMixin
+from .mixins.lsp_server_events_mixin import LSPServerEventsMixin
+
+
+
+class ProviderResponseCache(LSPClientEventsMixin, LSPServerEventsMixin, ProviderResponseCacheBase):
+    def __init__(self):
+        super(ProviderResponseCache, self).__init__()
+
+        self.executor       = ThreadPoolExecutor(max_workers = 1)
+        self.matchers: dict = {}
+        self.clients: dict  = {}
+        self._cache_refresh_timeout_id: int = None
+        self._last_active_language_id: str  = None
+
+
+    def create_client(
+        self,
+        lang_id: str = "python",
+        workspace_uri: str = "",
+        init_opts: dict = {
+    }) -> bool:
+        if lang_id in self.clients: return False
+
+        address                        = "127.0.0.1"
+        port                           = 9999
+        uri                            = f"ws://{address}:{port}/{lang_id}"
+        controller                     = LSPController()
+        controller.handle_lsp_response = self.server_response
+
+        controller.set_language(lang_id)
+        controller.set_socket(uri)
+        controller.start_client()
+
+        if not controller.ws_client.wait_for_connection(timeout = 5.0):
+            logger.error(f"Failed to connect to LSP server for {lang_id}")
+            return False
+
+        self.clients[lang_id] = controller
+        controller.send_initialize_message(init_opts, "", f"file://{workspace_uri}")
+
+        return True
+
+    def close_client(self, lang_id: str) -> bool:
+        if lang_id not in self.clients: return False
+
+        controller = self.clients.pop(lang_id)
+        controller.stop_client()
+
+        return True
+
+    def server_response(self, lsp_response: LSPResponseTypes):
+        logger.debug(f"LSP Response: { lsp_response }")
+
+        if isinstance(lsp_response, LSPResponseRequest):
+            if not self._last_active_language_id in self.clients:
+                logger.debug(f"No LSP client for '{self._last_active_language_id}', skipping 'server_response'")
+                return
+            
+            controller = self.clients[self._last_active_language_id]
+            event      = controller.get_event_by_id(lsp_response.id)
+
+            match event:
+                case "textDocument/completion":
+                    self._handle_completion_response(lsp_response.result)
+                case "textDocument/definition":
+                    self._handle_definition_response(lsp_response.result)
+                case _:
+                    ...
+        elif isinstance(lsp_response, LSPResponseNotification):
+            match lsp_response.method:
+                case "textDocument/publishDiagnostics":
+                    ...
+                case _:
+                    ...
+
+    def filter(self, word: str) -> list[dict]:
+        return []
+
+    def filter_with_context(self, context: GtkSource.CompletionContext)  -> list[dict]:
+        response = []
+        iter     = self.get_iter_correctly(context)
+        iter.backward_char()
+        char_str = iter.get_char()
+
+        if char_str == "." or char_str == " ":
+            for label, item in self.matchers.items():
+                response.append(item)
+
+            return response
+
+        word = self.get_word(context).rstrip()
+        for label, item in self.matchers.items():
+            if label.startswith(word):
+                response.append(item)
+
+        return response