pbesa 4.0.15__tar.gz → 4.0.17__tar.gz

{pbesa-4.0.15 → pbesa-4.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pbesa
-Version: 4.0.15
+Version: 4.0.17
 License-File: LICENSE
 License-File: LICENSE.txt
 Requires-Dist: pymongo>=4.6.3

pbesa-4.0.17/pbesa/celulas/celula_expertos.py

@@ -0,0 +1,57 @@
+import logging
+
+PROMPT = """
+Eres un clasificador de textos que determina a qué entidad o dependencia gubernamental colombiana corresponde un texto dado, basándose en la descripción de sus funciones. Tu tarea es analizar el siguiente texto y determinar la clase más apropiada.
+
+Responde únicamente con el nombre completo de la clase o con "NO_CORRESPONDE" si el texto no se ajusta a ninguna de las clases descritas. No agregues explicaciones ni comentarios adicionales.
+
+%s
+
+Opciones de respuesta posibles:
+
+DIMAR - Dirección General Marítima
+DNDA - Dirección Nacional de Derecho de Autor
+ICA - Instituto Colombiano Agropecuario
+SFC - Superintendencia Financiera de Colombia
+SIC - Superintendencia de Industria y Comercio - Competencia Desleal
+SIC - Superintendencia de Industria y Comercio - Propiedad Industrial
+SIC - Superintendencia de Industria y Comercio - Protección al Consumidor
+Supersalud - Superintendencia Nacional de Salud - Cobertura Servicios
+Supersalud - Superintendencia Nacional de Salud - Conflictos Devoluciones
+Supersalud - Superintendencia Nacional de Salud - Conflicto Entidades
+Supersalud - Superintendencia Nacional de Salud - Libre Elección
+Supersalud - Superintendencia Nacional de Salud - Multiafiliación
+Supersalud - Superintendencia Nacional de Salud - Reconocimiento Económico
+Supersociedades - Superintendencia de Sociedades - Liquidación Insolvencia
+Supersociedades - Superintendencia de Sociedades - Reorganización Insolvencia
+Supersociedades - Superintendencia de Sociedades - Validación Judicial
+Supersociedades - Superintendencia de Sociedades - Mercantiles
+NO_CORRESPONDE
+"""
+
+# Efectua la inferencia del modelo.
+def derive(service, text, conocimiento, max_tkns=4096) -> any:
+    try:
+        tmp_work_memory = []
+        prompt  = PROMPT % conocimiento
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        user_prompt = """
+        Texto: "%s"
+
+        Clasificación:
+        """ % text
+        tmp_work_memory.append({"role": "system", "content": prompt})
+        tmp_work_memory.append({"role": "user", "content": user_prompt})
+        res = service.generate(tmp_work_memory, max_tkns)
+        logging.info("\n")
+        logging.info(f"[Celula][Expertos][Text]: {text}")
+        logging.info(f"[Celula][Expertos][Respuesta]: {res}")
+        logging.info("\n")    
+        if not res or res == "":
+            res = text
+            logging.warning(f"[Celula][Expertos]: No obtener una respuesta.")
+        return res
+    except Exception as e:
+        logging.error(f"[Celula][Expertos]: Error al procesar: {text}")
+        logging.error(e)
+        return None

{pbesa-4.0.15 → pbesa-4.0.17}/pbesa/cognitive.py

@@ -26,7 +26,7 @@ from pbesa.social.dialog import (
     DialogState, imprimir_grafo, recorrer_interacciones, extraer_diccionario_nodos, 
     ActionNode, DeclarativeNode, GotoNode)
 from .celulas import (celula_casos, celula_consultas, celula_saludos, celula_datos_identificables,
-                      celula_generar_documento)
+                      celula_generar_documento, celula_expertos)
 from pbesa.social.prompts import ANALIZER_PROMPT, CLASSIFICATION_PROMPT, DERIVE_PROMPT, RECOVERY_PROMPT, ADAPT_PROMPT, SINTETIZER_PROMPT
 
 # --------------------------------------------------------
@@ -109,7 +109,7 @@ class AgentMetadata():
 # Define common functions
 # --------------------------------------------------------
 
-def define_service_provider(provider, ai_service=None) -> None:
+def define_service_provider(provider, ai_service=None, substitudes = False) -> None:
         # Define provider
         service = None
         service_provider = ServiceProvider()
@@ -126,7 +126,12 @@ def define_service_provider(provider, ai_service=None) -> None:
             service = AzureInference()
             service_provider.register("AZURE_INFERENCE", service)
         elif "AZURE_OPEN_AI_INFERENCE" in provider:
-            service = AzureOpenAIInference()
+            substitude_1 = None 
+            substitude_2 = None
+            if substitudes:
+                substitude_1 = AzureInference()
+                substitude_2 = AzureInference()
+            service = AzureOpenAIInference(substitude_1, substitude_2)
             service_provider.register("AZURE_OPEN_AI_INFERENCE", service)
         return service_provider, service
 
@@ -268,8 +273,8 @@ class AugmentedGeneration(ABC):
         """
         return self.model
     
-    def load_model(self, provider, config, ai_service=None) -> None:
-        self.__service_provider, service = define_service_provider(provider, ai_service)
+    def load_model(self, provider, config, ai_service=None, substitudes = False) -> None:
+        self.__service_provider, service = define_service_provider(provider, ai_service, substitudes)
         service.setup(config)
         self.__ai_service = service
     
@@ -286,12 +291,15 @@ class AugmentedGeneration(ABC):
         # Set up model
         self.setup_world()
 
-    def command_derive(self, command, query) -> str | None:
+    def command_derive(self, command, query, max_tkns=2000) -> 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"])
+            elif command == "EXPERTS":
+                retrieval = self.retrieval(query)
+                return celula_expertos.derive(self.__ai_service, query, retrieval, max_tkns)
             return None
         except Exception as e:
             traceback.print_exc()
@@ -650,8 +658,8 @@ class Dialog(ABC):
         # Set dialog state
         self.__dfa['start'] = iniciadores
 
-    def load_model(self, provider, config, ai_service=None) -> None:
-        self.__service_provider, service = define_service_provider(provider, ai_service)
+    def load_model(self, provider, config, ai_service=None, substitudes = False) -> None:
+        self.__service_provider, service = define_service_provider(provider, ai_service, substitudes)
         service.setup(config)
         self.__ai_service = service
     
@@ -781,7 +789,10 @@ class Dialog(ABC):
     
     def recovery(self, session_id, query):
         try:
-            self.__work_memory = self.system_work_memory.copy()
+            logging.info("\n\n\n")
+            logging.info(f"------------RECOVERY---------------")
+            logging.info("\n\n\n")    
+            self.__work_memory = self.__system_work_memory.copy()
             prompt = RECOVERY_PROMPT % query
             temp_work_memory = [{"role": "system", "content": prompt}]
             res = self.__ai_service.generate(temp_work_memory, max_tokens=500)
@@ -795,7 +806,9 @@ class Dialog(ABC):
                 self.notify(session_id, "STOP") 
                 return "Web", DialogState.START, self.RECOVERY_MSG, "Web"
         except Exception as e:
-            return self.RECOVERY_MSG
+            logging.error(f"Error en la recuperación: {e}")
+            msg = "Lo lamento, no puedo responder en este momento."
+            return "Web", DialogState.START, msg, "Web"
         
     def stage_one_classification(self, session_id, messages, attemps, query):
         """ Stage one classification """
@@ -880,7 +893,7 @@ class Dialog(ABC):
                 dicriminador = "consulta"
             else:
                 dicriminador = "caso"
-            self.notify(session_id, f"[Fase 1]: Clase -> {dicriminador}.")
+            self.notify(session_id, f"primera fase se identifica: {dicriminador}.")
             res = query
         else:
             logging.info("[Stage-1]: Respuesta con ambiguedad")
@@ -1272,10 +1285,10 @@ class Dialog(ABC):
                 res = self.__ai_service.generate(self.__work_memory, max_tokens=1000)
                 res = self.get_text(res)
                 logging.info(f"[Inferencia]:[Thought]:[DEEP]: {res}")
-                self.__work_memory.append({"role": "assistant", "content": res})
                 # Check if res is empty
-                if not res or res == "":
+                if not res or res == "" or res == "ERROR":
                     return self.recovery(session['session_id'], query)
+                self.__work_memory.append({"role": "assistant", "content": res})                
                 new_dialog_state = node.performative
                 if not node.is_terminal:
                     # Verifica recursion
@@ -1371,8 +1384,8 @@ class SpecialDispatch():
         # Reference of ADM
         self.adm = Adm()
 
-    def load_model(self, provider, config, ai_service=None) -> None:
-        self.__service_provider, service = define_service_provider(provider, ai_service)
+    def load_model(self, provider, config, ai_service=None, substitudes = False) -> None:
+        self.__service_provider, service = define_service_provider(provider, ai_service, substitudes)
         service.setup(config)
         self.__ai_service = service
         # Setup options dictionary
@@ -1386,7 +1399,7 @@ class SpecialDispatch():
                 role = agent.get_role()
                 self.__options_dict[agent_id] = role.description
         # Log
-        logging.info(f"Agentes disponibles: {self.__options_dict.keys()}")
+        #logging.info(f"Agentes disponibles: {self.__options_dict.keys()}")
     
     def get_text(self, mensaje) -> str:
         if mensaje:

{pbesa-4.0.15 → pbesa-4.0.17}/pbesa/kernel/util.py

@@ -73,7 +73,8 @@ class APIClient:
                 url=f"{self.base_url}/{endpoint}",
                 headers=self.headers,
                 json=payload,
-                timeout=self.timeout
+                timeout=self.timeout,
+                verify=False
             )
             response.raise_for_status()
             print(f"POST request to {endpoint} succeeded: {response.status_code}")

pbesa-4.0.17/pbesa/models.py

@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+"""
+----------------------------------------------------------
+-------------------------- PBESA -------------------------
+----------------------------------------------------------
+
+@autor AKEN
+@version 4.0.0
+@date 08/08/24
+"""
+
+# --------------------------------------------------------
+# Define resources
+# --------------------------------------------------------
+
+import json
+import logging
+import traceback
+from openai import AzureOpenAI
+from abc import ABC, abstractmethod
+from azure.ai.projects import AIProjectClient
+from azure.identity import DefaultAzureCredential
+from azure.ai.inference import ChatCompletionsClient
+from azure.core.credentials import AzureKeyCredential
+from azure.core.exceptions import HttpResponseError
+import time
+from openai import AzureOpenAI, RateLimitError, APIStatusError
+
+
+# --------------------------------------------------------
+# Define classes
+# --------------------------------------------------------
+
+class AIService(ABC):
+    """Abstract class for AI services."""
+
+    def __init__(self) -> None:
+        self.model:any = None
+        self.model_conf:dict = None
+        self.substitude_1_model:any = None
+        self.substitude_2_model:any = None
+        
+    @abstractmethod
+    def setup(self, config: dict) -> None:
+        """Method to setup the AI service."""
+        raise NotImplementedError("Method 'setup' must be implemented.")
+
+    @abstractmethod
+    def generate(self, work_memory, max_tokens=4096, temperature=0, top_p=0.9) -> str:
+        """Method to generate a response based on user input."""
+        raise NotImplementedError("Method 'setup' must be implemented.")
+
+class GPTService(AIService):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def setup(self, config: dict, work_memory) -> None:
+        try:
+            self.model:any = config['model']
+            self.model_conf:dict = config
+            self.__work_memory:list = work_memory
+        except Exception as e:
+            raise Exception("Could not setup GPTService: check the configuration.")
+
+    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}})
+                        logging.info("OpenAI response not completed")
+                        return None
+                    #self.log.info("OpenAI response completed", extra={'log_data': {'gpt_response': response}})
+                    logging.info("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}})
+                    logging.info("OpenAI response not completed")
+                    return None
+            else:
+                #self.log.warning("OpenAI response not completed", extra={'log_data': {'gpt_response': response}})
+                logging.info("OpenAI response not completed")
+                return None
+        except Exception as e:
+            trace_err = traceback.format_exc()
+            err = str(e) + " - " + trace_err
+            logging.info(err)
+            return None
+
+class AIFoundry(AIService):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def setup(self, config: dict, work_memory) -> None:        
+        self.model_conf:dict = config
+        self.__work_memory:list = work_memory
+        project = AIProjectClient.from_connection_string(
+            conn_str=config['PROJECT_CONNECTION_STRING'], credential=DefaultAzureCredential()
+        )
+        self.model:any = project.inference.get_chat_completions_client()
+
+    def generate(self) -> str:
+        response = self.model.complete(
+            model=self.model_conf['AIFOUNDRY_MODEL'],
+            messages=self.__work_memory,
+        )
+        return response.choices[0].message.content
+
+class AzureInference(AIService):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.max_tokens = 2000
+        self.deployment = "Llama-3.3-70B-Instruct"
+
+    def setup(self, config: dict, substitude=None) -> None:        
+        self.model_conf:dict = config
+        self.model:any = ChatCompletionsClient(
+            endpoint=config['AZURE_GENERAL_INFERENCE_SDK_ENDPOINT'], 
+            credential=AzureKeyCredential(config['AZURE_INFERENCE_SDK_KEY'])
+        )
+        self.max_tokens = self.model_conf['MAX_TOKENS']
+        if substitude:
+            self.deployment = substitude
+        else:
+            self.deployment = self.model_conf['DEPLOYMENT_NAME']
+
+    def generate(self, work_memory, max_tokens=2000, temperature=0, top_p=0.9) -> str:
+        again = False
+        try:
+            response = self.model.complete(
+                messages= work_memory,
+                model= self.deployment,
+                max_tokens= self.max_tokens
+            )
+            res = response.choices[0].message.content
+            if not res or res == "" or res == "ERROR":
+                again = True
+            else:
+                return res
+        except Exception as e:
+            # Maneja otros errores
+            again = True
+            trace_err = traceback.format_exc()
+            err = str(e) + " - " + trace_err
+            logging.info(f"Error en la respuesta de Azure: {err}")
+        if again:
+            if self.model_conf['SUBSTITUDE_DEPLOYMENT_NAME'] == "Llama-3.3-70B-Instruct":
+                logging.info("\n\n\n")
+                logging.info("----------------------------------------")
+                logging.info("Sustitudo atiendendo Llama-3.3-70B-Instruct")
+                try:
+                    logging.info("\n\n\n.............................................")
+                    logging.info("\n%s", json.dumps(work_memory, indent=4))
+                    logging.info("........................................\n\n\n")
+                    response = self.model.complete(
+                        messages= work_memory,
+                        model =self.model_conf['SUBSTITUDE_DEPLOYMENT_NAME'],
+                        max_tokens=self.model_conf['MAX_TOKENS']
+                    )
+                    logging.info("----------------------------------------")
+                    logging.info("\n\n\n")                    
+                    return response.choices[0].message.content
+                except Exception as e2:
+                    trace_err2 = traceback.format_exc()
+                    err2 = str(e2) + " - " + trace_err2
+                    logging.info(f"Error en la respuesta de Azure: {err2}")
+                    logging.info("----------------------------------------")
+                    logging.info("\n\n\n")                    
+                    raise e2
+        logging.error("\n\n\n****************************************")
+        logging.error("No se pudo generar una respuesta válida.")
+        return ""
+                    
+class AzureOpenAIInference(AIService):
+
+    def __init__(self, substitude_1_model = None, substitude_2_model  = None) -> None:
+        super().__init__()
+        self.substitude_1_model = substitude_1_model
+        self.substitude_2_model = substitude_2_model
+
+    def setup(self, config: dict) -> None:        
+        self.model_conf:dict = config
+        self.model:any = AzureOpenAI(
+            api_version=config['API_VERSION'],
+            azure_endpoint=config['AZURE_OPEN_AI_INFERENCE_SDK_ENDPOINT'],
+            api_key=config['AZURE_INFERENCE_SDK_KEY'],
+            max_retries=0
+        )
+        self.wait_time = 0
+        self.total_tokens = 0
+        self.exception_time = None
+        self.main_model_enable = True
+        self.current_time = time.time()
+        if self.substitude_1_model is not None:
+            self.substitude_1_model.setup(config, config['SUBSTITUDE_1_DEPLOYMENT_NAME'])
+        if self.substitude_2_model is not None:
+            self.substitude_2_model.setup(config, config['SUBSTITUDE_2_DEPLOYMENT_NAME'])
+        
+    def wait_strategy_for_rate_limit(self, exception):
+        self.wait_time = 0
+        self.main_model_enable = False
+        self.exception_time = time.time()
+        print(exception)
+        if isinstance(exception, (RateLimitError, APIStatusError)):
+            if hasattr(exception, 'response') and exception.response:
+                headers = exception.response.headers
+                retry_after_seconds = headers.get("Retry-After")
+                if retry_after_seconds:
+                    try:
+                        wait_time = int(retry_after_seconds)
+                        logging.info(f"Rate limit: Respetando header Retry-After: esperando {wait_time} segundos.")
+                        self.wait_time = wait_time
+                    except ValueError:
+                        logging.info(f"Rate limit: Retry-After header no es un entero ({retry_after_seconds}). Usando backoff exponencial.")
+                else: # No hay Retry-After, usar backoff exponencial
+                    logging.info("Rate limit: No se encontró header Retry-After. Usando backoff exponencial.")
+            else: # No hay objeto response, usar backoff exponencial
+                logging.info("Rate limit: No se encontró objeto response en la excepción. Usando backoff exponencial.")
+        if self.wait_time == 0:
+            logging.warning("Rate limit: No se especificó Retry-After. Usando backoff exponencial.")
+            # Si no se especifica Retry-After, usar backoff exponencial
+            self.wait_time = 2 ** (self.wait_time // 60)
+        
+    def generate(self, work_memory, max_tokens=4096, temperature=0, top_p=0.9) -> str:
+        again = False
+        try:            
+            if self.main_model_enable:
+                response = self.model.chat.completions.create(
+                    messages=work_memory,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    model=self.model_conf['DEPLOYMENT_NAME'],
+                )
+                if hasattr(response, 'usage') and response.usage is not None:
+                    logging.info("\n--- Uso de Tokens ---")
+                    logging.info(f"Tokens enviados (prompt): {response.usage.prompt_tokens}")
+                    logging.info(f"Tokens recibidos (completion): {response.usage.completion_tokens}")
+                    logging.info(f"Tokens totales: {response.usage.total_tokens}")
+                    self.total_tokens += response.usage.total_tokens
+                    current_t = time.time()
+                    elapsed_time = current_t - self.current_time
+                    logging.info(f"Tiempo transcurrido para la generación: {elapsed_time:.2f} segundos")
+                    # En minutos
+                    elapsed_time_minutes = elapsed_time / 60
+                    logging.info(f"Tiempo transcurrido para la generación: {elapsed_time_minutes:.2f} minutos")
+                    logging.info(f"Total de tokens generados hasta ahora: {self.total_tokens}")
+                    # Reinicia el contador si ha pasado más de 1 minuto
+                    if elapsed_time >= 60:
+                        logging.info("Reiniciando el contador de tiempo y tokens...")
+                        self.total_tokens = 0
+                        self.current_time = time.time()
+                        self.exception_time = None
+                    else:
+                        if self.total_tokens >= 40000:
+                            logging.info("Total de tokens alcanzado (40,000). Activando el modo de excepcion.")
+                            self.main_model_enable = False
+                            self.wait_time = 60 - elapsed_time + 5
+                            self.exception_time = time.time()
+                            logging.info(f"Esperando {self.wait_time} segundos antes de reintentar.")
+                    logging.info("---------------------\n")                    
+                else:
+                    logging.info("\n--- Uso de Tokens no disponible en la respuesta ---")
+                res = response.choices[0].message.content
+                if not res or res == "" or res == "ERROR":
+                    again = True
+                else:  
+                    return response.choices[0].message.content
+        except Exception as e:
+            self.wait_strategy_for_rate_limit(e)
+        #----------------------------------
+        # Exception mode
+        #----------------------------------
+        if not self.main_model_enable or again:
+            again = False
+            # Si ha pasado más de 1 minuto desde la última excepción, reinicia el modelo principal
+            current_t = time.time()
+            elapsed_time = current_t - self.exception_time
+            logging.info(f"Esperando {self.wait_time} segundos antes de reintentar. Transcurridos: {elapsed_time:.2f} segundos")
+            if elapsed_time >= self.wait_time:
+                logging.info("Reiniciando el modelo principal después de 1 minuto.")
+                self.main_model_enable = True
+                self.current_time = time.time()
+                self.total_tokens = 0
+            # Si el modelo principal está deshabilitado, intenta con los modelos de sustitución
+            try:
+                logging.warning("Modelo principal en espera. Intentando con el modelo de sustitución-1...")
+                if self.substitude_1_model is None:
+                    raise ValueError("No se ha configurado un modelo de sustitución-1.")
+                return self.substitude_1_model.generate(work_memory)                
+            except Exception as e:
+                try:
+                    logging.warning("Modelo principal en espera. Intentando con el modelo de sustitución-2...")
+                    if self.substitude_2_model is None:
+                        raise ValueError("No se ha configurado un modelo de sustitución-2.")
+                    return self.substitude_2_model.generate(work_memory)
+                except Exception as e2:
+                    trace_err = traceback.format_exc()
+                    err = str(e2) + " - " + trace_err
+                    logging.fatal(f"Error en la respuesta de Azure: {err}")
+                    raise e2
+    
+class ServiceProvider:
+    _services = {}
+
+    @classmethod
+    def register(cls, name: str, service):
+        """Register a service with a unique name."""
+        cls._services[name] = service
+
+    @classmethod
+    def get(cls, name: str):
+        """Retrieve a registered service."""
+        service = cls._services.get(name)
+        if not service:
+            raise ValueError(f"Service '{name}' not found!")
+        return service

{pbesa-4.0.15 → pbesa-4.0.17}/pbesa/social/collaborative_team.py

@@ -139,6 +139,12 @@ class DelegateAction(Action):
         """
         pass
 
+    def send_response(self, response:any) -> None:
+        """ Send response
+        @param response: Response
+        """
+        self.agent.get_gateway().put(response)
+
 # --------------------------------------------------------
 # Define ResponseAction component
 # --------------------------------------------------------

{pbesa-4.0.15 → pbesa-4.0.17}/pbesa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pbesa
-Version: 4.0.15
+Version: 4.0.17
 License-File: LICENSE
 License-File: LICENSE.txt
 Requires-Dist: pymongo>=4.6.3

{pbesa-4.0.15 → pbesa-4.0.17}/pbesa.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ pbesa/celulas/__init__.py
 pbesa/celulas/celula_casos.py
 pbesa/celulas/celula_consultas.py
 pbesa/celulas/celula_datos_identificables.py
+pbesa/celulas/celula_expertos.py
 pbesa/celulas/celula_generar_documento.py
 pbesa/celulas/celula_preguntas.py
 pbesa/celulas/celula_saludos.py

{pbesa-4.0.15 → pbesa-4.0.17}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='pbesa',
-    version='4.0.15',
+    version='4.0.17',
     packages=find_packages(),
     install_requires=[
         'pymongo>=4.6.3',