#wip(py): Building PseudoLoRAs filter.

JSON/AnP.settings.json

@@ -86,17 +86,28 @@
     "default_ai_interpreters" : {
         "anp_titles" : {
             "type" : "OllamaDriver", 
-            "host" : "localhost", 
-            "port" : 11434, 
+            "url" : "http://localhost:11434/api/generate/",
             "model" : "gemma3:1b", 
-            "pool" : "anp"
+            "pool" : "anp", 
+            "stream" : false, 
+            "format" : {
+                "type" : "array", 
+                "items" : {
+                    "type" : "string"
+                }
+            }, 
+            "orders" : [
+                "En base al mensaje del usuario y los Tokens que tengas de la conversación, selecciona posibles títulos que tengan que ver con ello.", 
+                "Devuelve una lista con los títulos seleccionados, sin ningún otro texto.", 
+                "Si el mensaje del usuario no tiene relación con ningún título, devuelve una lista vacía."
+            ]
         }, 
         "anp_responses" : {
             "type" : "OllamaDriver", 
-            "host" : "localhost", 
-            "port" : 11434, 
+            "url" : "http://localhost:11434/api/generate/",
             "model" : "gemma4:e4b", 
-            "pool" : "anp"
+            "pool" : "anp", 
+            "stream" : true
         }
     }, 
     "AnP_AIInterpretersManager_end" : null,

Python/Controllers/AIController.py

@@ -4,8 +4,8 @@
 from typing import Self, Any, Callable
 from Abstracts.ModelAbstract import ModelAbstract
 from Abstracts.ControllerAbstract import ControllerAbstract
-from Interfaces.Application.AnPInterface import AnPInterface
 from Models.RequestModel import RequestModel
+from Models.PseudoLoRAModel import PseudoLoRAModel
 
 class AIController(ControllerAbstract, ModelAbstract):
 
@@ -17,6 +17,19 @@ class AIController(ControllerAbstract, ModelAbstract):
     # def __get_data(self:Self, request:RequestModel, callback:Callable[..., Any|None]) -> None:
     #     self.anp.pseudoloras.get("anp_titles")
 
+    def __filter_loras_callback()
+
+    def __filter_loras(self:Self, message:str, loras:list[PseudoLoRAModel], keys:list[str]) -> None:
+
+        has_keys:bool = len(keys) > 0
+        
+        self.anp.ai_interpreters.request("anp_titles", None, "# Títulos\n\n" + "\n".join(
+            "- " + lora.title + "" for lora in loras if not has_keys or lora.key in keys
+        ) + "\n\n# Mensaje\n\n" + message, lambda id, response:None, [])
+
+    def get_pseudoloras(self:Self, request:RequestModel) -> None:
+        pass
+
     def test(self:Self, request:RequestModel) -> None:
         self.anp.ai_interpreters.request("anp_titles", None, request.get("message", "Hola"), lambda id, response: print((id, response.response)))
         request.set_response({

Python/Drivers/OllamaDriver.py

@@ -23,8 +23,8 @@ class OllamaDriver(AIInterpretersAbstract, ModelAbstract):
     def request(self:Self, 
         session:int|None, 
         message:str, 
-        orders:list[str] = [], 
-        callback:Optional[Callable[[int, AIResponseModel], None]] = None
+        callback:Optional[Callable[[int, AIResponseModel], None]] = None, 
+        orders:list[str] = []
     ) -> tuple[int|None, AIResponseModel]:
 
         response:Response

Python/Interfaces/Managers/AIInterpretersManagerInterface.py

@@ -23,7 +23,13 @@ class AIInterpretersManagerInterface(ABC):
     def remove(self:Self, keys:Optional[str|list[str]] = None) -> None:pass
 
     @abstractmethod
-    def request(self:Self, key:str, session:int|None, message:str, callback:Callable[[int, AIResponseModel], None]) -> int|None:pass
+    def request(self:Self, 
+        key:str, 
+        session:int|None, 
+        message:str, 
+        callback:Callable[[int, AIResponseModel], None], 
+        orders:list[str] = []
+    ) -> int|None:pass
     
     @abstractmethod
     def cancel_request(self:Self, key:str, id:int) -> None:pass

Python/Managers/AIInterpretersManager.py

@@ -88,7 +88,13 @@ class AIInterpretersManager:
                 if not has_interpreters and pool in self.__pool_requests:
                     del self.__pool_requests[pool]
 
-    def request(self:Self, key:str, session:int|None, message:str, callback:Callable[[int, AIResponseModel], None]) -> int|None:
+    def request(self:Self, 
+        key:str, 
+        session:int|None, 
+        message:str, 
+        callback:Callable[[int, AIResponseModel], None], 
+        orders:list[str] = []
+    ) -> int|None:
 
         i:int|None = None
 
@@ -96,7 +102,7 @@ class AIInterpretersManager:
 
             pool:str = self.__interpreters[key].pool
 
-            i = self.__pool_requests[pool].add(self.__interpreters[key], session, message, callback)
+            i = self.__pool_requests[pool].add(self.__interpreters[key], session, message, callback, orders)
             self.__pool_requests[pool].execute()
 
         return i

Python/Managers/PseudoLoRAsManager.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-from typing import Self, Any, Sequence, Callable
+from typing import Self, Any, Sequence, Callable, Optional
 from Interfaces.Application.AnPInterface import AnPInterface
 from Models.PseudoLoRAModel import PseudoLoRAModel
 from Utils.Common import Common
@@ -89,6 +89,15 @@ class PseudoLoRAsManager:
         for lora in self.__loras:
             lora.clean_cache()
 
+    def get_asynchronous(self:Self, 
+        each_callback:Callable[[list[PseudoLoRAModel], list[PseudoLoRAModel], Callable[[list[PseudoLoRAModel]], None]], bool], 
+        end_callback:Callable[[list[PseudoLoRAModel]], None], 
+        keys:list[str] = [], 
+        loras:Optional[list[PseudoLoRAModel]] = None,
+        results:list[PseudoLoRAModel] = []
+    ) -> None:
+        Common.execute(each_callback, )
+
     def get(self:Self, callback:Callable[[list[PseudoLoRAModel]], bool], keys:list[str] = []) -> list[tuple[str, str]]:
         
         next:list[PseudoLoRAModel] = []