pbesa 4.0.9__tar.gz → 4.0.11__tar.gz

pbesa-4.0.11/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.2
+Name: pbesa
+Version: 4.0.11
+License-File: LICENSE
+License-File: LICENSE.txt
+Requires-Dist: pymongo>=4.6.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: azure-ai-projects>=1.0.0b6
+Requires-Dist: azure-ai-inference>=1.0.0b9
+Requires-Dist: azure-identity>=1.21.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: scikit-learn>=1.6.1
+Dynamic: requires-dist

pbesa-4.0.11/pbesa/celulas/celula_datos_identificables.py

@@ -0,0 +1,53 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de datos. Tu tarea es clasificar si el siguiente texto contiene **datos personales** o **datos identificables de una entidad**.
+
+Responde únicamente con:
+- CONTIENE_DATOS
+- NO_CONTIENE_DATOS
+
+**Se considera que el texto CONTIENE_DATOS si incluye:**
+- Nombres completos de personas
+- Razón social o nombre de una empresa
+- Números de documento (cédula, NIT, etc.)
+- Direcciones físicas (calle, carrera, avenida, etc.)
+- Teléfonos o celulares
+- Correos electrónicos
+
+---
+
+**Ejemplos:**
+
+1. "Mi nombre es Carlos Ramírez y mi cédula es 1032478992." → CONTIENE_DATOS  
+2. "Quiero demandar a la empresa Alimentos S.A.S. ubicada en la Calle 45 #10-20." → CONTIENE_DATOS  
+3. "Puedes contactarme al correo johana.perez@gmail.com o al 3105678901." → CONTIENE_DATOS  
+4. "Necesito información sobre cómo presentar una queja." → NO_CONTIENE_DATOS  
+5. "Hola, buen día" → NO_CONTIENE_DATOS  
+6. "La empresa Agropecuaria S.A. está usando marcas similares a las nuestras." → CONTIENE_DATOS  
+7. "¿Cuál es el procedimiento para radicar una solicitud?" → NO_CONTIENE_DATOS
+
+---
+
+Texto: "%s"
+
+Clasificación:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = PROMPT % text
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Procesando: {text}")
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

pbesa-4.0.11/pbesa/celulas/celula_generar_documento.py

@@ -0,0 +1,44 @@
+import logging
+
+PROMPT = """
+Eres un asistente jurídico experto. Tu tarea es **extraer los datos** y generar el documento siguiendo una plantilla predefinida.
+
+Recibirás un texto que incluye:
+- Un relato de hechos sobre una posible infracción
+- Datos personales del demandante y del demandado (pueden venir con nombre de campo o en texto libre)
+- Información de contacto
+- Algunas veces: el nombre de la entidad ante la cual se presenta la demanda
+
+Usa el siguiente formato para estructurar tu respuesta. Si hay datos que no se encuentran, déjalos como estan en el formato.
+
+---
+
+%s
+
+---
+
+TEXTO DE ENTRADA:
+%s
+
+---
+
+DEMANDA FORMATEADA:
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, formato, text) -> any:
+    try:
+        logging.info(f"Procesando: {text}")
+        tmp_work_memory = []
+        prompt  = PROMPT % (formato, text)
+        tmp_work_memory.append({"role": "user", "content": prompt})
+        res = service.generate(tmp_work_memory)
+        logging.info(f"Respuesta: {res}")
+        if not res or res == "":
+            res = text
+            logging.warning(f"No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"Error al procesar: {text}")
+        logging.error(e)
+        return None

{pbesa-4.0.9 → pbesa-4.0.11}/pbesa/cognitive.py

@@ -21,11 +21,12 @@ from .mas import Adm
 from pydantic import BaseModel
 from typing import List, Optional
 from abc import ABC, abstractmethod
-from .celulas import celula_casos, celula_consultas, celula_saludos
 from pbesa.models import AIFoundry, AzureInference, GPTService, ServiceProvider
 from pbesa.social.dialog import (
     DialogState, imprimir_grafo, recorrer_interacciones, extraer_diccionario_nodos, 
-    ActionNode, DeclarativeNode, GotoNode) #, TerminalNode
+    ActionNode, DeclarativeNode, GotoNode)
+from .celulas import (celula_casos, celula_consultas, celula_saludos, celula_datos_identificables,
+                      celula_generar_documento)
 from pbesa.social.prompts import CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT
 # --------------------------------------------------------
 # Define DTOs
@@ -36,6 +37,7 @@ class InteraccionDTO(BaseModel):
     tipo: str
     texto: str
     actor: str
+    isExpanded: Optional[bool] = None
     equipo: Optional[str] = None
     herramienta: Optional[str] = None
     interacciones: List["InteraccionDTO"] = []
@@ -239,7 +241,8 @@ class AugmentedGeneration(ABC):
         # Define role
         self.__work_memory.append({"role": "user", "content": self.__role.objective})
         self.__work_memory.append({"role": "user", "content": self.__role.arquetype})
-        self.__work_memory.append({"role": "user", "content": self.__role.example})
+        if self.__role.example:
+            self.__work_memory.append({"role": "user", "content": self.__role.example})
     
     def load_metadata(self, agent_metadata:AgentMetadata) -> None:
         """ Load metadata method
@@ -273,6 +276,45 @@ class AugmentedGeneration(ABC):
         # Set up model
         self.setup_world()
 
+    def command_derive(self, command, query) -> str | None:
+        try:
+            if command == "DATA_TYPE":
+                return celula_datos_identificables.derive(self.__ai_service, query)
+            elif command == "GENERATE_DOCUMENT":
+                return celula_generar_documento.derive(self.__ai_service, query["template"], query["text"])
+            return None
+        except Exception as e:
+            traceback.print_exc()
+            return None
+    
+    def get_text(self, mensaje) -> str:
+        if mensaje:
+            mensaje_limpio = mensaje.replace("<|im_start|>user<|im_sep|>", "").replace("<|im_start|>system<|im_sep|>", "") \
+                .replace("<|im_start|>", "").replace("<|im_sep|>", "").replace("<|im_end|>", "") \
+                .replace("[Usuario]: ", "").replace("[Sistema]: ", "") \
+                .replace("<|user|>", "").replace("<|system|>", "")
+            return mensaje_limpio.strip()
+        else:
+            return ""
+        
+    def custom_derive(self, instructions, prompt) -> str:
+        """ Generate method
+        :return: str
+        """
+        try:
+            instantane_memory = self.__work_memory.copy()
+            instantane_memory.append({"role": "user", "content": instructions})
+            instantane_memory.append({"role": "user", "content": prompt})
+            text = self.__ai_service.generate(instantane_memory)
+            text = self.get_text(text)
+            logging.info(f"Thought: {text}")
+            return text
+        except Exception as e:
+            traceback.print_exc()
+            logging.info(f"------------RESET---------------")
+            self.reset()
+            return "Lo lamento, no puedo responder en este momento"
+        
     def derive(self, query) -> str:
         """ Generate method
         :return: str
@@ -282,21 +324,18 @@ class AugmentedGeneration(ABC):
             prompt = DERIVE_PROMPT % (content, query)
             instantane_memory = self.__work_memory.copy()
             instantane_memory.append({"role": "user", "content": prompt})
+            logging.info("")
+            logging.info("----- MEMORY -----")
+            logging.info("\n%s", json.dumps(instantane_memory, indent=4))
+            logging.info("-------------------")
+            logging.info("")
             text = self.__ai_service.generate(instantane_memory)
-            logging.info(f"Thought: {text}")
-            if self.__def_tool_dict:
-                tool = self.__def_tool_dict.get(self.__role.tool)
-                if tool:
-                    text = tool(text)
-                else:
-                    text = "No se ha encontrado la herramienta"
+            text = self.get_text(text)
             return text
         except Exception as e:
             traceback.print_exc()
-
             logging.info(f"------------RESET---------------")
             self.reset()
-
             return "Lo lamento, no puedo responder en este momento"
 
     def get_role(self) -> Role:
@@ -305,6 +344,12 @@ class AugmentedGeneration(ABC):
         """
         return self.__role
     
+    def get_tool_dict(self):
+        """ Get tool dict method
+        :return: dict
+        """
+        return self.__def_tool_dict
+    
     @abstractmethod
     def retrieval(self, query) -> str:
         """ Set retrieval method
@@ -320,6 +365,25 @@ class AugmentedGeneration(ABC):
         """
         pass
 
+# --------------------------------------------------------
+# Define Agent Tool component
+# --------------------------------------------------------
+
+class AgentTool(ABC):
+    """ Agent Tool class """
+
+    def __init__(self, agent) -> None:
+        """ Constructor method """
+        self.agent = agent
+
+    @abstractmethod
+    def tool(self, request: dict) -> None:
+        """ Tool method
+        :param request: request
+        :return: None
+        """
+        pass
+    
 # --------------------------------------------------------
 # Define Rational component
 # --------------------------------------------------------
@@ -701,7 +765,7 @@ class Dialog(ABC):
                 "performative": dialog_state,
                 "counter": counter
             }
-            logging.info(f"Recovery attemps: {self.__recovery["counter"]}")
+            logging.info(f"Recovery attemps: {self.__recovery['counter']}")
             # Verifica si se ha alcanzado el límite de recuperación
             if self.__recovery['counter'] <= 3 and self.__visited_nodes <= 3:                    
                 select_node = None
@@ -717,13 +781,15 @@ class Dialog(ABC):
                     consulta = celula_consultas.derive(self.__ai_service, query)
                     saludo = celula_saludos.derive(self.__ai_service, query)
                     # Verifica si es un saludo
-                    es_saludo = saludo == "SALUDO" and consulta == "NO_PREGUNTA" and caso == "NO_QUEJA_DEMANDA"
-                    es_consulta = consulta == "PREGUNTA_O_SOLICITUD" and caso == "NO_QUEJA_DEMANDA" and saludo == "NO_SALUDO"
-                    es_caso = caso == "QUEJA_DEMANDA" and consulta == "NO_PREGUNTA" and saludo == "NO_SALUDO"
+                    es_saludo = ("SALUDO" in saludo) and ("NO_PREGUNTA" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and not ("NO_SALUDO" in saludo)
+                    es_consulta = ("PREGUNTA_O_SOLICITUD" in consulta) and ("NO_QUEJA_DEMANDA" in caso) and ("NO_SALUDO" in saludo) and not ("NO_PREGUNTA" in consulta)
+                    es_caso = ("QUEJA_DEMANDA" in caso) and ("NO_PREGUNTA" in consulta) and ("NO_SALUDO" in saludo) and not ("NO_QUEJA_DEMANDA" in caso)
+                    logging.info(f"==> Saludo: {saludo}, Consulta: {consulta}, Caso: {caso}")
+                    logging.info(f"==> Es saludo: {es_saludo}, Es consulta: {es_consulta}, Es caso: {es_caso}")
                     # Verifica los casos
                     dicriminador = "Ninguno"
                     if es_saludo or es_consulta or es_caso:
-                        logging.info("Sin ambiguedad")
+                        logging.info("Respuesta Clara")
                         self.notify("discriminando...")
                         if es_saludo:
                             dicriminador = "saluda"
@@ -732,12 +798,14 @@ class Dialog(ABC):
                         elif es_caso:
                             dicriminador = "caso"
                     else:
-                        logging.info("Hay ambiguedad")
+                        logging.info("Respuesta con ambiguedad")
                         self.notify("identificando ambiguedad...")
-                        if saludo == "SALUDO":
-                            dicriminador = "saluda"
-                        else:
+                        if caso == "QUEJA_DEMANDA":
+                            dicriminador = "caso"
+                        elif consulta == "PREGUNTA_O_SOLICITUD":
                             dicriminador = "consulta"
+                        elif saludo == "SALUDO":
+                            dicriminador = "saluda"
                     #--------------------------
                     # Obtiene los hijos del 
                     # nodo
@@ -880,7 +948,8 @@ class Dialog(ABC):
                 #---------------------------
                 # Efectua inferencia
                 new_owner, new_dialog_state, res, team = self.do_transition(owner, node, query)
-                res = self.get_text(res)
+                if res and not res == "ERROR" and isinstance(res, str):
+                    res = self.get_text(res)
                 return new_owner, new_dialog_state, res, team
             else:
                 logging.info(f"------------RESET---------------")
@@ -909,19 +978,32 @@ class Dialog(ABC):
                 if node.tool and not node.tool == "Ninguno":
                     self.notify("aplicando herramienta...")
                     logging.info(f"-> node tool: {node.tool}")
-                    self.__work_memory.append({"role": "user", "content": node.text})
-                    logging.info("-----")
-                    logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
-                    logging.info("-----")         
-                    res = self.__ai_service.generate(self.__work_memory)
-                    logging.info(f"-> node tool: {res}")
-                    res = self.get_text(res)
+
+                    res = query
+                    if "consulta" in node.text.lower():
+                        logging.info(f"-> node team -> consulta: {query}")
+                    else:
+                        #self.__work_memory.append({"role": "user", "content": node.text})
+                        logging.info("-----")
+                        logging.info("\n%s", json.dumps(self.__work_memory, indent=4))
+                        logging.info("-----")         
+                        res = self.__ai_service.generate(self.__work_memory)
+                        logging.info(f"-> node tool: {res}")
+                        res = self.get_text(res)
                     # Check if res is empty
                     if not res or res == "":
                         self.notify("no pude hacer uso de la herramienta")
                         return self.recovery(query)
                     logging.info(f"-> node tool: envia -> {res}")
-                    res = self.team_inquiry(node.team, res, node.tool, False)   
+                    res = self.team_inquiry(node.team, res, node.tool, False)
+
+                    if res and not res == "ERROR" and not isinstance(res, str):
+                        logging.info(f"COMANDO -> node tool: recibe -> {res}")
+                        self.reset()
+                        self.notify("STOP")
+                        return "Web", DialogState.START, res, "Web"
+
+
                 else:
                     self.notify("realizando llamada...")
                     #------------------------------
@@ -1055,6 +1137,9 @@ class Dialog(ABC):
             if isinstance(data, str):
                 text = data
             elif isinstance(data, dict):
+                if 'command' in data:
+                    logging.info(f"Es un comando.")
+                    return data
                 text = data['dto']['text'] if data and 'dto' in data and data['dto']['text'] is not None else ''
             else:
                 raise ValueError("Respuesta mal formada")

{pbesa-4.0.9 → pbesa-4.0.11}/pbesa/social/dispatcher_team.py

@@ -34,12 +34,17 @@ operate in an agile and effective manner.
 # --------------------------------------------------------
 
 import logging
+import traceback
+import pandas as pd
 from abc import abstractmethod
 from .worker import Task, Worker
 from ..kernel.agent import Queue
 from ..kernel.agent import Agent
 from ..kernel.agent import Action
 from ..kernel.util import generate_short_uuid
+from ..cognitive import Dialog, AugmentedGeneration
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.feature_extraction.text import CountVectorizer
 
 # ----------------------------------------------------------
 # Defines system component exceptions
@@ -53,6 +58,178 @@ class DispatcherException(Exception):
 # Define Delegate Action
 # --------------------------------------------------------
 
+class AgentDto():
+    """ Data Transfer Object """
+    def __init__(self, agent_id:str) -> None:
+        """ Constructor
+        @param agent_id: Agent ID
+        """
+        self.id = agent_id
+
+class SelectedDispatcher(Action):
+    """ An action is a response to the occurrence of an event """
+
+    def __init__(self) -> None:
+        """ Constructor """  
+        super().__init__()
+        self.__rewier = {}
+        self.__planilla = {}
+
+    def active_timeout(self, ag, time: int) -> None:
+        """ Active timeout
+        @param time: Time
+        """
+        logging.info(f"[Delegate] Send event timeout {time}")
+        self.adm.send_event(ag, 'timeout', {'time': time, 'command': 'start'})
+
+    def calculate_close(self, description, data: any) -> bool:
+        """ Check close
+        @param data: Data
+        @return: True if the agent is closed, False otherwise
+        """
+        text1 = description
+        text2 = data['dto']['text'] if data and 'dto' in data and data['dto']['text'] is not None else ''
+        logging.info(f"Text1: {text1}")
+        logging.info(f"Query: {text2}")
+        documents = [text1, text2]
+        count_vectorizer = CountVectorizer()
+        sparse_matrix = count_vectorizer.fit_transform(documents)
+        doc_term_matrix = sparse_matrix.todense()
+        df = pd.DataFrame(
+            doc_term_matrix,
+            columns=count_vectorizer.get_feature_names_out(),
+            index=[text1, text2],
+        )
+        res = cosine_similarity(df, df)
+        similarity = res[0][1]
+        return similarity
+
+    @abstractmethod    
+    def manual_selection(self, data: any) -> object:
+        """ Manual selection
+        @param data: Data
+        @return: Tuple with the agent and the score
+        """
+        raise NotImplementedError("The method manual_selection must be implemented in the subclass")
+    
+    def execute(self, data: any) -> None:
+        """ 
+        Response.
+        @param data Event data 
+        """
+        try:
+            logging.info('Assign to agent...')
+            session_id = data['dto']['session']['session_id'] if 'session' in data['dto'] else None
+            agent_list = self.agent.get_agent_list()
+            agent_count = len(agent_list)
+            logging.debug('List of agents: ' + str(agent_list))
+            if session_id in self.__planilla:
+                mayor_ag_id = self.__planilla[session_id]
+                logging.info('The session is already assigned')
+                logging.info(f'The agent {mayor_ag_id} will be assigned')
+                exit = False
+                while not exit:
+                    ag = self.agent.get_free_queue().get()
+                    agent_obj = self.adm.get_agent(ag)
+                    # Get the role
+                    if mayor_ag_id == agent_obj.id:
+                        logging.info(f'The agent {ag} is assigned')
+                        self.agent.get_request_dict()[ag] = {
+                            'gateway': data['gateway'],
+                            'dtoList': []
+                        }
+                        self.adm.send_event(ag, 'task', data['dto'])
+                        self.__rewier[ag] = 0
+                        exit = True
+                    else:
+                        logging.debug('The agent does not match the role')
+                        self.adm.send_event(agent_obj.get_controller(), 'notify', ag)
+                        if ag in self.__rewier:
+                            self.__rewier[ag] = self.__rewier[ag] + 1
+                        else:
+                            self.__rewier[ag] = 0
+                        if self.__rewier[ag] >= agent_count * 3:
+                            data['gateway'].put('ERROR')
+                            logging.error('[Error, toAssign]: The agent is not available')
+            else:
+                score_mayor = 0 
+                mayor_ag = self.manual_selection(data['dto'])
+                if mayor_ag:
+                    score_mayor = 7
+                else:
+                    # Get the agent asocciated with the data.
+                    for agent_id in agent_list:
+                        agent = self.adm.get_agent(agent_id)
+                        # Chec if the agent is instance of AugmentedGeneration
+                        if isinstance(agent, Dialog) or isinstance(agent, AugmentedGeneration):
+                            # Get the role
+                            role = agent.get_role()
+                            score = self.calculate_close(role.description, data)
+                            logging.info(f"Score: {score}")
+                            if score > score_mayor:
+                                score_mayor = score
+                                mayor_ag = agent
+                        else:
+                            logging.info(f"The {agent_id} is not instance of AugmentedGeneration or Dialog")
+                # Check if the mayor agent is the same as the agent        
+                if score_mayor > 0.501:
+                    logging.info(f'The agent {mayor_ag.id} will be assigned')
+                    exit = False
+                    while not exit:
+                        ag = self.agent.get_free_queue().get()
+                        agent_obj = self.adm.get_agent(ag)
+                        # Chec if the agent is instance of AugmentedGeneration
+                        if isinstance(agent_obj, Dialog) or isinstance(agent_obj, AugmentedGeneration):
+                            # Get the role
+                            if mayor_ag.id == agent_obj.id:
+                                logging.info(f'The agent {ag} is assigned')
+                                self.agent.get_request_dict()[ag] = {
+                                    'gateway': data['gateway'],
+                                    'dtoList': []
+                                }
+                                self.adm.send_event(ag, 'task', data['dto'])
+                                self.__rewier[ag] = 0
+                                exit = True
+                                self.__planilla[session_id] = mayor_ag.id
+                            else:
+                                logging.debug('The agent does not match the role')
+                                self.adm.send_event(agent_obj.get_controller(), 'notify', ag)
+                                if ag in self.__rewier:
+                                    self.__rewier[ag] = self.__rewier[ag] + 1
+                                else:
+                                    self.__rewier[ag] = 0
+                                if self.__rewier[ag] >= agent_count * 3:
+                                    data['gateway'].put('ERROR')
+                                    logging.error('[Error, toAssign]: The agent is not available')
+                        else:
+                            self.agent.get_request_dict()[ag] = {
+                                'gateway': data['gateway'],
+                                'dtoList': []
+                            }
+                            self.adm.send_event(ag, 'task', data['dto'])
+                            exit = True
+                else:
+                    ag = self.agent.get_free_queue().get()
+                    self.agent.get_request_dict()[ag] = {
+                        'gateway': data['gateway'],
+                        'dtoList': []
+                    }
+                    self.adm.send_event(ag, 'task', data['dto'])
+                # Check timeout    
+                if 'timeout' in self.agent.state:
+                    self.active_timeout(ag, self.agent.state['timeout'])
+                else:
+                    data['gateway'].put('ERROR')
+                    logging.error('[Delegate]: Timeout not defined in the state as "timeout" key')
+        except Exception as e:
+            traceback.print_exc()
+            logging.error(f"[Delegate][{self.agent.id}]: {str(e)}")
+            data['gateway'].put('ERROR')
+
+# --------------------------------------------------------
+# Define Delegate Action by default
+# --------------------------------------------------------
+
 class Delegate(Action):
     """ An action is a response to the occurrence of an event """
 

pbesa-4.0.11/pbesa.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.2
+Name: pbesa
+Version: 4.0.11
+License-File: LICENSE
+License-File: LICENSE.txt
+Requires-Dist: pymongo>=4.6.3
+Requires-Dist: requests>=2.32.3
+Requires-Dist: azure-ai-projects>=1.0.0b6
+Requires-Dist: azure-ai-inference>=1.0.0b9
+Requires-Dist: azure-identity>=1.21.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: scikit-learn>=1.6.1
+Dynamic: requires-dist

{pbesa-4.0.9 → pbesa-4.0.11}/pbesa.egg-info/SOURCES.txt

@@ -73,6 +73,8 @@ pbesa.egg-info/top_level.txt
 pbesa/celulas/__init__.py
 pbesa/celulas/celula_casos.py
 pbesa/celulas/celula_consultas.py
+pbesa/celulas/celula_datos_identificables.py
+pbesa/celulas/celula_generar_documento.py
 pbesa/celulas/celula_saludos.py
 pbesa/celulas/web.py
 pbesa/kernel/__init__.py

pbesa-4.0.11/pbesa.egg-info/requires.txt

@@ -0,0 +1,7 @@
+pymongo>=4.6.3
+requests>=2.32.3
+azure-ai-projects>=1.0.0b6
+azure-ai-inference>=1.0.0b9
+azure-identity>=1.21.0
+pandas>=2.2.3
+scikit-learn>=1.6.1

pbesa-4.0.11/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+
+
+setup(
+    name='pbesa',
+    version='4.0.11',
+    packages=find_packages(),
+    install_requires=[
+        'pymongo>=4.6.3',
+        'requests>=2.32.3',
+        'azure-ai-projects>=1.0.0b6',
+        'azure-ai-inference>=1.0.0b9',
+        'azure-identity>=1.21.0',
+        'pandas>=2.2.3',
+        'scikit-learn>=1.6.1',
+    ],
+)

pbesa-4.0.9/PKG-INFO

@@ -1,11 +0,0 @@
-Metadata-Version: 2.2
-Name: pbesa
-Version: 4.0.9
-License-File: LICENSE
-License-File: LICENSE.txt
-Requires-Dist: pymongo==4.6.3
-Requires-Dist: requests==2.32.3
-Requires-Dist: azure-ai-projects==1.0.0b6
-Requires-Dist: azure-ai-inference==1.0.0b9
-Requires-Dist: azure-identity==1.20.0
-Dynamic: requires-dist

pbesa-4.0.9/pbesa.egg-info/PKG-INFO

@@ -1,11 +0,0 @@
-Metadata-Version: 2.2
-Name: pbesa
-Version: 4.0.9
-License-File: LICENSE
-License-File: LICENSE.txt
-Requires-Dist: pymongo==4.6.3
-Requires-Dist: requests==2.32.3
-Requires-Dist: azure-ai-projects==1.0.0b6
-Requires-Dist: azure-ai-inference==1.0.0b9
-Requires-Dist: azure-identity==1.20.0
-Dynamic: requires-dist

pbesa-4.0.9/pbesa.egg-info/requires.txt

@@ -1,5 +0,0 @@
-pymongo==4.6.3
-requests==2.32.3
-azure-ai-projects==1.0.0b6
-azure-ai-inference==1.0.0b9
-azure-identity==1.20.0

pbesa-4.0.9/setup.py

@@ -1,16 +0,0 @@
-from setuptools import setup, find_packages
-
-
-
-setup(
-    name='pbesa',
-    version='4.0.9',
-    packages=find_packages(),
-    install_requires=[
-        'pymongo==4.6.3',
-        'requests==2.32.3',
-        'azure-ai-projects==1.0.0b6',
-        'azure-ai-inference==1.0.0b9',
-        'azure-identity==1.20.0'
-    ],
-)