pbesa 2.1__py3-none-any.whl → 4.0.0__py3-none-any.whl

pbesa/__init__.py

@@ -1,3 +1,4 @@
-from .engine import *
-from .kernel import *
-from .middleware import *
+from .kernel import *
+from .social import *
+from .remote import *
+from .cognitive import *

pbesa/cognitive.py

@@ -0,0 +1,475 @@
+# -*- coding: utf-8 -*-
+"""
+----------------------------------------------------------
+-------------------------- PBESA -------------------------
+----------------------------------------------------------
+
+@autor AKEN
+@version 4.0.0
+@date 08/08/24
+"""
+
+# --------------------------------------------------------
+# Define resources
+# --------------------------------------------------------
+
+import traceback
+from abc import ABC, abstractmethod
+from pbesa.social.dialog import DialogState, ActionNode, DeclarativeNode, TerminalNode
+
+# --------------------------------------------------------
+# Define OpenAI Adapter component
+# --------------------------------------------------------
+
+class OpenAIAdapter():
+
+    def __init__(self, model:any, model_conf:dict, work_memory:list) -> None:
+        """ Constructor method
+        :param model: model
+        :param model_conf: model_conf
+        :param work_memory: work_memory
+        """
+        self.model:any = model
+        self.model_conf:dict = model_conf
+        self.__work_memory:list = work_memory
+
+    def generate(self) -> str:
+        """ Generate method
+        :return: str
+        """
+        try:
+            # Genera texto con OpenAI.
+            self.model.api_key = self.model_conf['API_KEY']
+            engine = self.model_conf['OPENAI_ENGINE']
+            response = self.model.ChatCompletion.create(
+                model = engine,
+                messages = self.__work_memory
+            )
+            # Verifica si se obtuvo respuesta.
+            if response['choices'][0]['finish_reason'] == 'completed' or response['choices'][0]['finish_reason'] == 'stop':
+                res = response['choices'][0]['message']['content']
+                try:
+                    if not res or res == 'null' or res == 'N/A' or 'N/A' in res:
+                        #self.log.warning("OpenAI response not completed", extra={'log_data': {'gpt_response': response}})
+                        print("OpenAI response not completed")
+                        return None
+                    #self.log.info("OpenAI response completed", extra={'log_data': {'gpt_response': response}})
+                    print("OpenAI response completed")
+                    self.__work_memory.append({"role": "assistant", "content": res})
+                    return res
+                except:
+                    #self.log.warning("OpenAI response not completed", extra={'log_data': {'gpt_response': response}})
+                    print("OpenAI response not completed")
+                    return None
+            else:
+                #self.log.warning("OpenAI response not completed", extra={'log_data': {'gpt_response': response}})
+                print("OpenAI response not completed")
+                return None
+        except Exception as e:
+            trace_err = traceback.format_exc()
+            err = str(e) + " - " + trace_err
+            #self.log.error(err)
+            print(err)
+            return None
+
+# --------------------------------------------------------
+# Define Model component
+# --------------------------------------------------------
+
+class Model(ABC):
+    """ Model class """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+    
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    @abstractmethod
+    def load_model(self, config:dict) -> None:
+        """ Load model method
+        :param config: config
+        """ 
+        pass
+
+    @abstractmethod
+    def train_model(self, model_config:dict, data:any) -> any:
+        """ Train model method
+        :param model_config: model_config
+        :param data: data
+        :return: any
+        """
+        pass
+
+    @abstractmethod
+    def evaluate_model(self, data:any) -> any:
+        """ Validate model method
+        :param data: data
+        :return: any
+        """
+        pass
+
+    @abstractmethod
+    def fit_model(self, model_config:dict, data:any) -> any:
+        """ Fit model method
+        :param model_config: model_config
+        :param data: data
+        :return: any
+        """
+        pass
+
+    @abstractmethod
+    def predict(self, data:any) -> any:
+        """ Predict method
+        :param data: data
+        :return: any
+        """
+        pass
+
+# --------------------------------------------------------
+# Define Generative component
+# --------------------------------------------------------
+
+class Generative(ABC):
+    """ Generative class """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+    
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    def set_model(self, model:any) -> None:
+        """ Set model method
+        :param model: model
+        """ 
+        self.model = model
+
+    def generate(self, data:any, config:dict) -> any:
+        """ Generate method
+        :param data: data
+        :param config: config
+        :return: any
+        """
+        pass
+
+# --------------------------------------------------------
+# Define Augmented Generation component
+# --------------------------------------------------------
+
+class AugmentedGeneration(ABC):
+    """ Augmented Generation """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+        self.model_conf:dict = None
+        self.__work_memory:list = []
+        # Define role
+        role = self.define_role() 
+        self.__role = role.strip() if role else "Undefined"
+        # Define model adapter
+        self.__model_adapter = None
+        # Set up model
+        self.set_up_model()
+
+    def set_up_model(self):
+        """ Set up model method """
+        # Define role
+        self.__work_memory.append({"role": "system", "content": self.__role})
+        
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    def load_model(self, model:any, model_conf:dict) -> None:
+        """ Set model method
+        :param model: model
+        :param model_conf: Configuration
+        """
+        self.model = model
+        self.model_conf = model_conf
+        self.__model_adapter = OpenAIAdapter(self.model, self.model_conf, self.__work_memory)
+    
+    def update_world_model(self, fact:str) -> None:
+        """ Update world model method
+        :param fact: fact
+        :return: str
+        """
+        self.__work_memory.append({"role": "user", "content": fact})
+
+    def reset(self) -> None:
+        """ Reset method """
+        self.__work_memory = []
+        # Set up model
+        self.set_up_model()
+
+    def derive(self, query) -> str:
+        """ Generate method
+        :return: str
+        """
+        content = self.retrieval(query)
+        self.__work_memory.append({"role": "system", "content": f"A partir de la siguiente información: {content} responde a la siguiente consulta:"})
+        self.__work_memory.append({"role": "user", "content": query})
+        return self.__model_adapter.generate()
+
+    @abstractmethod
+    def define_role(self) -> str:
+        """ Set role set method """
+        pass
+
+    @abstractmethod
+    def retrieval(self, query) -> str:
+        """ Set retrieval method
+        :param query: query
+        :return: str
+        """
+        pass
+
+# --------------------------------------------------------
+# Define Rational component
+# --------------------------------------------------------
+
+class Rational(ABC):
+    """ Rational class """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+        self.__work_memory:list = []
+    
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    def set_model(self, model:any) -> None:
+        """ Set model method
+        :param model: model
+        """ 
+        self.model = model
+    
+    def derive(self, data:any, config:dict) -> any:
+        """ Generate method
+        :param data: data
+        :param config: config
+        :return: any
+        """
+        pass
+
+# --------------------------------------------------------
+# Define Production component
+# --------------------------------------------------------
+
+class Production(ABC):
+    """ Rational class """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+        self.model_conf:dict = None
+        self.__work_memory:list = []
+        # Define role
+        role = self.define_role() 
+        self.__role = role.strip() if role else "Undefined"
+        # Define rule set
+        self.__rule_set = self.define_rule_set()
+        # Define example
+        self.__example = self.define_example()
+        # Define model adapter
+        self.__model_adapter = None
+        # Set up model
+        self.set_up_model()
+
+    def set_up_model(self):
+        """ Set up model method """
+        # Define role
+        self.__work_memory.append({"role": "system", "content": self.__role})
+        # Iterate over the rule set
+        self.__work_memory.append({"role": "system", "content": "Sigue estrictamente las siguientes reglas:"})
+        for rule in self.__rule_set:
+            self.__work_memory.append({"role": "system", "content": rule})
+        self.__work_memory.append({"role": "system", "content": "Ejemplo:"})
+        # Define example
+        self.__work_memory.append({"role": "system", "content": self.__example})
+        
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    def load_model(self, model:any, model_conf:dict) -> None:
+        """ Set model method
+        :param model: model
+        :param model_conf: Configuration
+        """
+        self.model = model
+        self.model_conf = model_conf
+        self.__model_adapter = OpenAIAdapter(self.model, self.model_conf, self.__work_memory)
+
+    def get_rule_set(self) -> list:
+        """ Get rule set method
+        :return: list
+        """
+        return self.__rule_set
+    
+    def update_world_model(self, fact:str) -> None:
+        """ Update world model method
+        :param fact: fact
+        :return: str
+        """
+        self.__work_memory.append({"role": "user", "content": fact})
+
+    def reset(self) -> None:
+        """ Reset method """
+        self.__work_memory = []
+        # Set up model
+        self.set_up_model()
+
+    def derive(self) -> str:
+        """ Generate method
+        :return: str
+        """
+        return self.__model_adapter.generate()
+
+    @abstractmethod
+    def define_role(self) -> str:
+        """ Set role set method """
+        pass
+
+    @abstractmethod
+    def define_rule_set(self) -> tuple:
+        """ Set rule set method """
+        pass
+
+    @abstractmethod
+    def define_example(self) -> str:
+        """ Set example set method """
+        pass
+
+# --------------------------------------------------------
+# Define Dialog component
+# --------------------------------------------------------
+
+class Dialog(ABC):
+    """ Dialog """
+
+    def __init__(self) -> None:
+        """ Constructor method """
+        self.model:any = None
+        self.model_conf:dict = None
+        self.__work_memory:list = []
+        # Define role
+        role = self.define_role() 
+        self.__role = role.strip() if role else "Undefined"
+        # Define DFA
+        dfa = self.define_dfa()
+        self.__dfa = dfa if dfa else "Undefined"
+        # Set dialog state
+        self.__dialog_state = DialogState.START
+        # Define model adapter
+        self.__model_adapter = None
+        # Set up model
+        self.set_up_model()
+        
+
+    def set_up_model(self):
+        """ Set up model method """
+        # Define role
+        self.__work_memory.append({"role": "system", "content": self.__role})
+        
+    def get_model(self) -> any:
+        """ Get model method 
+        :return: model
+        """
+        return self.model
+    
+    def set_dialog_state(self, dialog_state) -> None:
+        """ Set dialog state method
+        :param dialog_state: dialog_state
+        """
+        self.__dialog_state = dialog_state
+    
+    def get_dialog_state(self) -> DialogState:
+        """ Get dialog state method
+        :return: DialogState
+        """
+        return self.__dialog_state
+    
+    def load_model(self, model:any, model_conf:dict) -> None:
+        """ Set model method
+        :param model: model
+        :param model_conf: Configuration
+        """
+        self.model = model
+        self.model_conf = model_conf
+        self.__model_adapter = OpenAIAdapter(self.model, self.model_conf, self.__work_memory)
+    
+    def update_world_model(self, fact:str) -> None:
+        """ Update world model method
+        :param fact: fact
+        :return: str
+        """
+        self.__work_memory.append({"role": "user", "content": fact})
+
+    def reset(self) -> None:
+        """ Reset method """
+        self.__work_memory = []
+        # Set up model
+        self.set_up_model()
+
+    def transition(self, dialog_state, query) -> str:
+        """ Generate method
+        :return: str
+        """
+        text = ""
+        path_tag = None
+        node = self.__dfa[dialog_state]
+        if isinstance(node, DeclarativeNode):
+            text = node.text
+            self.__work_memory.append({"role": "system", "content": text})
+            self.__work_memory.append({"role": "user", "content": query})
+        elif isinstance(node, ActionNode):
+            node, text = node.action(node, query)
+            print("-> node:", node.performative)
+            print("-> text:", text)
+            self.__work_memory.append({"role": "user", "content": query})
+            self.__work_memory.append({"role": "system", "content": text})
+            self.__work_memory.append({"role": "system", "content": text})
+            new_owner = node.owner
+            new_dialog_state = node.performative
+            return new_owner, new_dialog_state, self.__model_adapter.generate()
+        path_tag = next((tag for tag in ['do', 'yes', 'no'] if tag in node.children), None)
+        print("path_tag", path_tag)       
+        if path_tag:
+            new_owner = node.children[path_tag].owner
+            new_dialog_state = node.children[path_tag].performative
+            if not isinstance(node, TerminalNode):
+                print("=> new_owner:", new_owner, "new_dialog_state:", new_dialog_state)
+                return new_owner, new_dialog_state, self.__model_adapter.generate()
+            print("=> new_owner:", new_owner, "new_dialog_state:", new_dialog_state)
+            return new_owner, new_dialog_state, None
+        else:
+            raise Exception("No path found")
+
+    @abstractmethod
+    def define_role(self) -> str:
+        """ Set role set method """
+        pass
+
+    @abstractmethod
+    def define_dfa(self) -> dict:
+        """ Set role set method """
+        pass

pbesa/kernel/__init__.py

@@ -1,6 +1,4 @@
-from .adapter import *
-from .agent import *
-from .io import *
-from .res import *
-from .system import *
-from .util import *
+from .adapter import *
+from .agent import *
+from .io import *
+from .res import *

pbesa/kernel/adapter.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+"""
+----------------------------------------------------------
+-------------------------- PBESA -------------------------
+----------------------------------------------------------
+
+@autor AKEN
+@version 4.0.0
+@date 08/08/24
+"""
+
+# --------------------------------------------------------
+# Define resources
+# --------------------------------------------------------
+
+from pymongo import MongoClient
+from pymongo.cursor import Cursor
+from abc import ABC, abstractmethod
+from .io.system_file import SystemFile
+
+# --------------------------------------------------------
+# Define Adapter component
+# --------------------------------------------------------
+
+class Adapter(ABC):
+    """ Base adapter class """
+    
+    # Adapter data
+    data = None
+    # Adapter configuration
+    config = None
+    
+    def __init__(self) -> None:
+        """ Constructor """
+        super().__init__()
+
+    @abstractmethod
+    def setup(self) -> None:
+        """ Set up adapter """
+        pass
+
+    @abstractmethod
+    def response(self) -> None:
+        """ Response adapter """
+        pass
+    
+    @abstractmethod
+    def request(self) -> None:
+        """ Request adapter """
+        pass
+
+    @abstractmethod
+    def finalize(self) -> None:
+        """ Finalize adapter """
+        pass
+
+# --------------------------------------------------------
+# Define FileAdapter component
+# --------------------------------------------------------
+
+class FileAdapter(Adapter):
+    """ File adapter class """
+
+    def __init__(self, config) -> None:
+        """ Constructor 
+        :param config: Configuration
+        """
+        self.config = config
+        super().__init__()
+
+    def setup(self) -> None:
+        """ Set up adapter """
+        if self.config['type'] == 'JSON':            
+            sf = SystemFile(self.config['path'])
+            self.data = sf.read_json_file()
+
+    def response(self) -> None:
+        """ Response adapter """
+        pass
+    
+    def request(self):
+        """ Request adapter """
+        return self.data
+
+    def finalize(self):
+        """ Finalize adapter """
+        pass
+
+# --------------------------------------------------------
+# Define MongoAdapter component
+# --------------------------------------------------------
+
+class MongoAdapter(Adapter):
+    """ Mongo adapter class """
+
+    # Database
+    db = None
+    # Configuration
+    conf = None
+    # Client
+    client = None
+
+    def __init__(self, conf:dict) -> None:
+        """ Constructor
+        :param conf: Configuration
+        """
+        self.conf = conf
+        super().__init__()
+
+    def setup(self) -> None:
+        """ Set up adapter """
+        self.client = MongoClient()
+        self.db = self.client[self.conf['database']]
+
+    def response(self, response:str) -> None:
+        """ Response adapter """
+        pass
+    
+    def request(self) -> None:
+        """ Request adapter """
+        pass
+        
+    def finalize(self) -> None:
+        """ Finalize adapter """
+        pass
+
+    def get_all(self, collection:str) -> Cursor:
+        """ Get all objects from collection
+        :param collection: Collection
+        """
+        coll = self.db[collection]
+        return coll.find()
+
+    def get_object(self, collection:str, query:dict) -> any:
+        """ Get object from collection
+        :param collection: Collection
+        :param query: Query
+        """
+        coll = self.db[collection]
+        return coll.find_one(query)
+
+    def get_object_by_id(self, collection:str, id:str) -> any:
+        """ Get object from collection by ID
+        :param collection: Collection
+        :param id: ID
+        """
+        coll = self.db[collection]
+        return coll.find_one({"_id": id})
+
+    def insert_object(self, collection:str, dto:dict) -> None:
+        """ Insert object in collection
+        :param collection: Collection
+        :param dto: Data transfer object
+        """
+        coll = self.db[collection]
+        return coll.insert_one(dto).inserted_id
+
+    def update_object(self, collection:str, id:str, dto:dict) -> None:
+        """ Update object in collection
+        :param collection: Collection
+        :param id: ID
+        :param dto: Data transfer object
+        """
+        coll = self.db[collection]
+        return coll.replace_one({"_id": id}, dto, True)