abacusai 1.4.15__tar.gz → 1.4.17__tar.gz

{abacusai-1.4.15/abacusai.egg-info → abacusai-1.4.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abacusai
-Version: 1.4.15
+Version: 1.4.17
 Summary: Abacus.AI Python Client Library
 Home-page: https://github.com/abacusai/api-python
 Author: Abacus.AI

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/__init__.py

@@ -191,6 +191,7 @@ from .realtime_monitor import RealtimeMonitor
 from .refresh_pipeline_run import RefreshPipelineRun
 from .refresh_policy import RefreshPolicy
 from .refresh_schedule import RefreshSchedule
+from .regenerate_llm_external_application import RegenerateLlmExternalApplication
 from .resolved_feature_group_template import ResolvedFeatureGroupTemplate
 from .routing_action import RoutingAction
 from .schema import Schema
@@ -218,4 +219,4 @@ from .webhook import Webhook
 from .workflow_node_template import WorkflowNodeTemplate
 
 
-__version__ = "1.4.15"
+__version__ = "1.4.17"

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_class/ai_agents.py

@@ -340,7 +340,7 @@ class WorkflowGraphNode(ApiClass):
             workflow_node.function = function
             workflow_node.function_name = function.__name__
             workflow_node.source_code = get_clean_function_source_code_for_agent(function)
-        elif function_name and source_code:
+        elif function_name and (source_code or template_metadata):
             workflow_node.function_name = function_name
             workflow_node.source_code = source_code
         else:
@@ -371,7 +371,7 @@ class WorkflowGraphNode(ApiClass):
         elif isinstance(input_schema, WorkflowNodeInputSchema):
             instance_input_schema = input_schema
         elif isinstance(input_schema, list) and all(isinstance(field, str) for field in input_schema):
-            instance_input_schema = JSONSchema.from_fields_list(input_schema)
+            instance_input_schema = WorkflowNodeInputSchema.from_fields_list(input_schema)
         else:
             raise ValueError('workflow_graph_node', 'Invalid input schema. Must be a WorkflowNodeInputSchema or a list of field names.')
 
@@ -381,7 +381,7 @@ class WorkflowGraphNode(ApiClass):
         elif isinstance(output_schema, WorkflowNodeOutputSchema):
             instance_output_schema = output_schema
         elif isinstance(output_schema, list) and all(isinstance(field, str) for field in output_schema):
-            instance_output_schema = JSONSchema.from_fields_list(output_schema)
+            instance_output_schema = WorkflowNodeOutputSchema.from_fields_list(output_schema)
         else:
             raise ValueError('workflow_graph_node', 'Invalid output schema. Must be a WorkflowNodeOutputSchema or a list of output section names.')
 
@@ -598,21 +598,25 @@ class WorkflowNodeTemplateInput(ApiClass):
     Args:
         name (str): A unique name of the input.
         is_required (bool): Indicates whether the input is required. Defaults to False.
+        description (str): The description of this input.
     """
     name: str
     is_required: bool = dataclasses.field(default=False)
+    description: str = dataclasses.field(default='')
 
     def to_dict(self):
         return {
             'name': self.name,
-            'is_required': self.is_required
+            'is_required': self.is_required,
+            'description': self.description
         }
 
     @classmethod
     def from_dict(cls, mapping: dict):
         return cls(
             name=mapping['name'],
-            is_required=mapping.get('is_required', False)
+            is_required=mapping.get('is_required', False),
+            description=mapping.get('description', '')
         )
 
 
@@ -624,19 +628,23 @@ class WorkflowNodeTemplateOutput(ApiClass):
     Args:
         name (str): The name of the output.
         variable_type (WorkflowNodeOutputType): The type of the output.
+        description (str): The description of this output.
     """
     name: str
     variable_type: enums.WorkflowNodeOutputType = dataclasses.field(default=enums.WorkflowNodeOutputType.ANY)
+    description: str = dataclasses.field(default='')
 
     def to_dict(self):
         return {
             'name': self.name,
-            'variable_type': self.variable_type.value
+            'variable_type': self.variable_type.value,
+            'description': self.description
         }
 
     @classmethod
     def from_dict(cls, mapping: dict):
         return cls(
             name=mapping['name'],
-            variable_type=enums.WorkflowNodeOutputType(mapping.get('variable_type', 'ANY'))
+            variable_type=enums.WorkflowNodeOutputType(mapping.get('variable_type', 'ANY')),
+            description=mapping.get('description', '')
         )

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_class/dataset.py

@@ -63,15 +63,18 @@ class DocumentProcessingConfig(ApiClass):
             self.extract_bounding_boxes = self.highlight_relevant_text  # Highlight_relevant text acts as a wrapper over extract_bounding_boxes
 
     def _detect_ocr_mode(self):
-        if self.document_type is None:  # Maps to Auto mode
-            return self.ocr_mode  # TODO: Link with paddle OCR
-        if self.document_type == DocumentType.TEXT:
-            return OcrMode.DEFAULT
-        elif self.document_type == DocumentType.TABLES_AND_FORMS:
-            return OcrMode.LAYOUT
-        elif self.document_type == DocumentType.EMBEDDED_IMAGES:
-            return OcrMode.SCANNED
-        return OcrMode.DEFAULT
+        if self.document_type is not None:
+            if self.document_type == DocumentType.TEXT:
+                return OcrMode.DEFAULT
+            elif self.document_type == DocumentType.TABLES_AND_FORMS:
+                return OcrMode.LAYOUT
+            elif self.document_type == DocumentType.EMBEDDED_IMAGES:
+                return OcrMode.SCANNED
+            elif self.document_type == DocumentType.SCANNED_TEXT:
+                return OcrMode.DEFAULT
+        if self.ocr_mode is not None:
+            return self.ocr_mode
+        return OcrMode.AUTO
 
 
 @dataclasses.dataclass

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_class/document_retriever.py

@@ -17,6 +17,8 @@ class VectorStoreConfig(ApiClass):
         score_multiplier_column (str): If provided, will use the values in this metadata column to modify the relevance score of returned chunks for all queries.
         prune_vectors (bool): Transform vectors using SVD so that the average component of vectors in the corpus are removed.
         index_metadata_columns (bool): If True, metadata columns of the FG will also be used for indexing and querying.
+        use_document_summary (bool): If True, uses the summary of the document in addition to chunks of the document for indexing and querying.
+        summary_instructions (str): Instructions for the LLM to generate the document summary.
     """
     chunk_size: int = dataclasses.field(default=None)
     chunk_overlap_fraction: float = dataclasses.field(default=None)
@@ -25,6 +27,8 @@ class VectorStoreConfig(ApiClass):
     score_multiplier_column: str = dataclasses.field(default=None)
     prune_vectors: bool = dataclasses.field(default=None)
     index_metadata_columns: bool = dataclasses.field(default=None)
+    use_document_summary: bool = dataclasses.field(default=None)
+    summary_instructions: str = dataclasses.field(default=None)
 
 
 DocumentRetrieverConfig = VectorStoreConfig

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_class/enums.py

@@ -409,7 +409,6 @@ class ApplicationConnectorType(ApiEnum):
     GOOGLESHEETSUSER = 'GOOGLESHEETSUSER'
     GOOGLEDOCSUSER = 'GOOGLEDOCSUSER'
     ONEDRIVEUSER = 'ONEDRIVEUSER'
-    JIRAAUTH = 'JIRAAUTH'
     TEAMSSCRAPER = 'TEAMSSCRAPER'
     GITHUBUSER = 'GITHUBUSER'
     OKTASAML = 'OKTASAML'

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_class/model.py

@@ -483,6 +483,9 @@ class ChatLLMTrainingConfig(TrainingConfig):
         unknown_answer_phrase (str): Fallback response when the LLM can't find an answer.
         enable_tool_bar (bool): Enable the tool bar in Enterprise ChatLLM to provide additional functionalities like tool_use, web_search, image_gen, etc.
         enable_inline_source_citations (bool): Enable inline citations of the sources in the response.
+        response_format: (str): When set to 'JSON', the LLM will generate a JSON formatted string.
+        json_response_instructions (str): Instructions to be followed while generating the json_response if `response_format` is set to "JSON". This can include the schema information if the schema is dynamic and its keys cannot be pre-determined.
+        json_response_schema (str): Specifies the JSON schema that the model should adhere to if `response_format` is set to "JSON". This should be a json-formatted string where each field of the expected schema is mapped to a dictionary containing the fields 'type', 'required' and 'description'. For example - '{"sample_field": {"type": "integer", "required": true, "description": "Sample Field"}}'
     """
     document_retrievers: List[str] = dataclasses.field(default=None)
     num_completion_tokens: int = dataclasses.field(default=None)
@@ -516,6 +519,9 @@ class ChatLLMTrainingConfig(TrainingConfig):
     unknown_answer_phrase: str = dataclasses.field(default=None)
     enable_tool_bar: bool = dataclasses.field(default=None)
     enable_inline_source_citations: bool = dataclasses.field(default=None)
+    response_format: str = dataclasses.field(default=None)
+    json_response_instructions: str = dataclasses.field(default=None)
+    json_response_schema: str = dataclasses.field(default=None)
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.CHAT_LLM

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/api_client_utils.py

@@ -51,14 +51,15 @@ def get_non_nullable_type(types):
 
 
 class StreamingHandler(str):
-    def __new__(cls, value, context=None, section_key=None, data_type='text'):
+    def __new__(cls, value, context=None, section_key=None, data_type='text', is_transient=False):
         if context:
-            cls.process_streaming_data(value, context, section_key, data_type)
+            cls.process_streaming_data(
+                value, context, section_key, data_type, is_transient)
         return str.__new__(cls, value)
 
     @classmethod
-    def process_streaming_data(cls, value, context, section_key, data_type):
-        if hasattr(context, 'streamed_section_response') and hasattr(context, 'streamed_response'):
+    def process_streaming_data(cls, value, context, section_key, data_type, is_transient):
+        if hasattr(context, 'streamed_section_response') and hasattr(context, 'streamed_response') and not is_transient:
             if data_type == 'text':
                 if section_key:
                     entry_exists = False
@@ -400,6 +401,7 @@ class DocstoreUtils:
     PAGE_LLM_OCR = 'page_llm_ocr'
     PAGE_TABLE_TEXT = 'page_table_text'
     MARKDOWN_FEATURES = 'markdown_features'
+    MULTI_MODE_OCR_TEXT = 'multi_mode_ocr_text'
     DOCUMENT_PROCESSING_CONFIG = 'document_processing_config'
     DOCUMENT_PROCESSING_VERSION = 'document_processing_version'
 
@@ -591,7 +593,7 @@ class DocstoreUtils:
             document_data[cls.EMBEDDED_TEXT] = combine_page_texts(info.get(
                 cls.EMBEDDED_TEXT) or info.get(cls.PAGE_TEXT) or '' for info in page_infos)
             page_texts = None
-            for k in [cls.PAGE_MARKDOWN, cls.PAGE_LLM_OCR, cls.PAGE_TABLE_TEXT]:
+            for k in [cls.MULTI_MODE_OCR_TEXT, cls.PAGE_MARKDOWN, cls.PAGE_LLM_OCR, cls.PAGE_TABLE_TEXT]:
                 if page_infos[0].get(k) and not document_data.get(cls.PAGE_MARKDOWN):
                     document_data[cls.PAGE_MARKDOWN] = page_texts = [
                         page.get(k, '') for page in page_infos]

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/client.py

@@ -43,10 +43,11 @@ from .api_class import (
     PredictionArguments, ProblemType, ProjectFeatureGroupConfig,
     PythonFunctionType, ResponseSection, SamplingConfig, Segment,
     StreamingConnectorDatasetConfig, TrainingConfig, VectorStoreConfig,
-    WorkflowGraph, get_clean_function_source_code_for_agent
+    WorkflowGraph, WorkflowGraphNode, WorkflowNodeTemplateConfig,
+    get_clean_function_source_code_for_agent
 )
 from .api_class.abstract import get_clean_function_source_code, get_clean_function_source_code_for_agent, snake_case
-from .api_class.ai_agents import WorkflowGraph
+from .api_class.ai_agents import WorkflowGraph, WorkflowNodeTemplateConfig
 from .api_class.blob_input import Blob, BlobInput
 from .api_class.enums import AgentInterface
 from .api_class.segments import ResponseSection, Segment
@@ -177,6 +178,7 @@ from .use_case_requirements import UseCaseRequirements
 from .user import User
 from .web_search_response import WebSearchResponse
 from .webhook import Webhook
+from .workflow_node_template import WorkflowNodeTemplate
 
 
 DEFAULT_SERVER = 'https://api.abacus.ai'
@@ -616,7 +618,7 @@ class BaseApiClient:
         client_options (ClientOptions): Optional API client configurations
         skip_version_check (bool): If true, will skip checking the server's current API version on initializing the client
     """
-    client_version = '1.4.15'
+    client_version = '1.4.17'
 
     def __init__(self, api_key: str = None, server: str = None, client_options: ClientOptions = None, skip_version_check: bool = False, include_tb: bool = False):
         self.api_key = api_key
@@ -1498,16 +1500,18 @@ class ReadOnlyClient(BaseApiClient):
             application_connector_id (str): Unique string identifier for the application connector."""
         return self._call_api('listApplicationConnectorObjects', 'GET', query_params={'applicationConnectorId': application_connector_id})
 
-    def get_connector_auth(self, service: Union[ApplicationConnectorType, str], scopes: List = None) -> ApplicationConnector:
+    def get_connector_auth(self, service: Union[ApplicationConnectorType, str] = None, scopes: List = None, name: str = None, is_user_level: bool = True) -> ApplicationConnector:
         """Get the authentication details for a given connector.
 
         Args:
             service (ApplicationConnectorType): The service name.
             scopes (List): The scopes to request for the connector.
+            name (str): Name of the connector.
+            is_user_level (bool): Type of connector to be fetched (user level or org level).
 
         Returns:
             ApplicationConnector: The application connector with the authentication details."""
-        return self._call_api('getConnectorAuth', 'GET', query_params={'service': service, 'scopes': scopes}, parse_type=ApplicationConnector)
+        return self._call_api('getConnectorAuth', 'GET', query_params={'service': service, 'scopes': scopes, 'name': name, 'isUserLevel': is_user_level}, parse_type=ApplicationConnector)
 
     def list_streaming_connectors(self) -> List[StreamingConnector]:
         """Retrieves a list of all streaming connectors along with their corresponding attributes.
@@ -3607,6 +3611,35 @@ class ApiClient(ReadOnlyClient):
         _request_context.topological_dfs_stack = workflow_info['topological_dfs_stack']
         return workflow_info['run_info']
 
+    def execute_workflow_node(self, node: WorkflowGraphNode, inputs: dict):
+        source_code = None
+        function_name = None
+        if node.template_metadata:
+            template_metadata = node.template_metadata
+            template_name = template_metadata.get('template_name')
+            template = self._call_api('_getWorkflowNodeTemplate', 'GET', query_params={
+                                      'name': template_name}, parse_type=WorkflowNodeTemplate)
+            if not template:
+                raise Exception(f'Template {template_name} not found')
+            function_name = template.function_name
+            configs = template_metadata.get('configs') or {}
+            template_configs = [WorkflowNodeTemplateConfig.from_dict(
+                template_config) for template_config in template.template_configs]
+            for template_config in template_configs:
+                if template_config.name not in configs:
+                    if template_config.is_required:
+                        raise Exception(
+                            f'Missing value for required template config {template_config.name}')
+                    else:
+                        configs[template_config.name] = template_config.default_value
+            source_code = template.source_code.format(**configs)
+        else:
+            source_code = node.source_code
+            function_name = node.function_name
+        exec(source_code, globals())
+        func = eval(function_name)
+        return func(**inputs)
+
     def create_agent_from_function(self, project_id: str, agent_function: callable, name: str = None, memory: int = None, package_requirements: list = None, description: str = None, evaluation_feature_group_id: str = None, workflow_graph: WorkflowGraph = None):
         """
         [Deprecated]
@@ -3925,26 +3958,27 @@ class ApiClient(ReadOnlyClient):
         """
         return get_object_from_context(self, _request_context, 'proxy_app_caller', str) is not None
 
-    def stream_message(self, message: str) -> None:
+    def stream_message(self, message: str, is_transient: bool = False) -> None:
         """
         Streams a message to the current request context. Applicable within a AIAgent execute function.
         If the request is from the abacus.ai app, the response will be streamed to the UI. otherwise would be logged info if used from notebook or python script.
 
         Args:
             message (str): The message to be streamed.
+            is_transient (bool): If True, the message will be marked as transient and will not be persisted on reload in external chatllm UI. Transient messages are useful for streaming interim updates or results.
         """
         request_id = self._get_agent_app_request_id()
         caller = self._get_agent_async_app_caller()
         proxy_caller = self._is_proxy_app_caller()
         if request_id and caller:
             extra_args = {'stream_type': StreamType.MESSAGE.value,
-                          'response_version': '1.0'}
+                          'response_version': '1.0', 'is_transient': is_transient}
             if hasattr(_request_context, 'agent_workflow_node_id'):
                 extra_args.update(
                     {'agent_workflow_node_id': _request_context.agent_workflow_node_id})
             self._call_aiagent_app_send_message(
                 request_id, caller, message=message, extra_args=extra_args, proxy_caller=proxy_caller)
-        return StreamingHandler(message, _request_context)
+        return StreamingHandler(message, _request_context, is_transient=is_transient)
 
     def stream_section_output(self, section_key: str, value: str) -> None:
         """
@@ -8653,17 +8687,6 @@ Creates a new feature group defined as the union of other feature group versions
             AgentConversation: Contains a list of AgentConversationMessage that represents the conversation."""
         return self._proxy_request('constructAgentConversationMessagesForLLM', 'POST', query_params={}, body={'deploymentConversationId': deployment_conversation_id, 'externalSessionId': external_session_id, 'includeDocumentContents': include_document_contents}, parse_type=AgentConversation, is_sync=True)
 
-    def get_llm_app_response(self, llm_app_name: str, prompt: str) -> LlmResponse:
-        """Queries the specified LLM App to generate a response to the prompt. LLM Apps are LLMs tailored to achieve a specific task like code generation for a specific service's API.
-
-        Args:
-            llm_app_name (str): The name of the LLM App to use for generation.
-            prompt (str): The prompt to use for generation.
-
-        Returns:
-            LlmResponse: The response from the LLM App."""
-        return self._call_api('getLLMAppResponse', 'POST', query_params={}, body={'llmAppName': llm_app_name, 'prompt': prompt}, parse_type=LlmResponse)
-
     def validate_workflow_graph(self, workflow_graph: Union[dict, WorkflowGraph], agent_interface: Union[AgentInterface, str] = AgentInterface.DEFAULT, package_requirements: list = []) -> dict:
         """Validates the workflow graph for an AI Agent.
 
@@ -8682,6 +8705,17 @@ Creates a new feature group defined as the union of other feature group versions
             package_requirements (list): A list of package requirement strings. For example: ['numpy==1.2.3', 'pandas>=1.4.0']."""
         return self._call_api('extractAgentWorkflowInformation', 'POST', query_params={}, body={'workflowGraph': workflow_graph, 'agentInterface': agent_interface, 'packageRequirements': package_requirements})
 
+    def get_llm_app_response(self, llm_app_name: str, prompt: str) -> LlmResponse:
+        """Queries the specified LLM App to generate a response to the prompt. LLM Apps are LLMs tailored to achieve a specific task like code generation for a specific service's API.
+
+        Args:
+            llm_app_name (str): The name of the LLM App to use for generation.
+            prompt (str): The prompt to use for generation.
+
+        Returns:
+            LlmResponse: The response from the LLM App."""
+        return self._call_api('getLLMAppResponse', 'POST', query_params={}, body={'llmAppName': llm_app_name, 'prompt': prompt}, parse_type=LlmResponse)
+
     def create_document_retriever(self, project_id: str, name: str, feature_group_id: str, document_retriever_config: Union[dict, VectorStoreConfig] = None) -> DocumentRetriever:
         """Returns a document retriever that stores embeddings for document chunks in a feature group.
 

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/deployment_conversation_event.py

@@ -34,9 +34,10 @@ class DeploymentConversationEvent(AbstractApiClass):
             llmDisplayName (str): The display name of the LLM model used to generate the response. Only used for system-created bots.
             llmBotIcon (str): The icon location of the LLM model used to generate the response. Only used for system-created bots.
             formResponse (dict): Contains form data response from the user when a Form Segment is given out by the bot.
+            routedLlm (str): The LLM that was chosen by RouteLLM to generate the response.
     """
 
-    def __init__(self, client, role=None, text=None, timestamp=None, messageIndex=None, regenerateAttempt=None, modelVersion=None, searchResults=None, isUseful=None, feedback=None, feedbackType=None, docInfos=None, keywordArguments=None, inputParams=None, attachments=None, responseVersion=None, agentWorkflowNodeId=None, nextAgentWorkflowNodeId=None, chatType=None, agentResponse=None, error=None, segments=None, streamedData=None, streamedSectionData=None, highlights=None, llmDisplayName=None, llmBotIcon=None, formResponse=None):
+    def __init__(self, client, role=None, text=None, timestamp=None, messageIndex=None, regenerateAttempt=None, modelVersion=None, searchResults=None, isUseful=None, feedback=None, feedbackType=None, docInfos=None, keywordArguments=None, inputParams=None, attachments=None, responseVersion=None, agentWorkflowNodeId=None, nextAgentWorkflowNodeId=None, chatType=None, agentResponse=None, error=None, segments=None, streamedData=None, streamedSectionData=None, highlights=None, llmDisplayName=None, llmBotIcon=None, formResponse=None, routedLlm=None):
         super().__init__(client, None)
         self.role = role
         self.text = text
@@ -65,11 +66,12 @@ class DeploymentConversationEvent(AbstractApiClass):
         self.llm_display_name = llmDisplayName
         self.llm_bot_icon = llmBotIcon
         self.form_response = formResponse
+        self.routed_llm = routedLlm
         self.deprecated_keys = {}
 
     def __repr__(self):
         repr_dict = {f'role': repr(self.role), f'text': repr(self.text), f'timestamp': repr(self.timestamp), f'message_index': repr(self.message_index), f'regenerate_attempt': repr(self.regenerate_attempt), f'model_version': repr(self.model_version), f'search_results': repr(self.search_results), f'is_useful': repr(self.is_useful), f'feedback': repr(self.feedback), f'feedback_type': repr(self.feedback_type), f'doc_infos': repr(self.doc_infos), f'keyword_arguments': repr(self.keyword_arguments), f'input_params': repr(self.input_params), f'attachments': repr(self.attachments), f'response_version': repr(
-            self.response_version), f'agent_workflow_node_id': repr(self.agent_workflow_node_id), f'next_agent_workflow_node_id': repr(self.next_agent_workflow_node_id), f'chat_type': repr(self.chat_type), f'agent_response': repr(self.agent_response), f'error': repr(self.error), f'segments': repr(self.segments), f'streamed_data': repr(self.streamed_data), f'streamed_section_data': repr(self.streamed_section_data), f'highlights': repr(self.highlights), f'llm_display_name': repr(self.llm_display_name), f'llm_bot_icon': repr(self.llm_bot_icon), f'form_response': repr(self.form_response)}
+            self.response_version), f'agent_workflow_node_id': repr(self.agent_workflow_node_id), f'next_agent_workflow_node_id': repr(self.next_agent_workflow_node_id), f'chat_type': repr(self.chat_type), f'agent_response': repr(self.agent_response), f'error': repr(self.error), f'segments': repr(self.segments), f'streamed_data': repr(self.streamed_data), f'streamed_section_data': repr(self.streamed_section_data), f'highlights': repr(self.highlights), f'llm_display_name': repr(self.llm_display_name), f'llm_bot_icon': repr(self.llm_bot_icon), f'form_response': repr(self.form_response), f'routed_llm': repr(self.routed_llm)}
         class_name = "DeploymentConversationEvent"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
@@ -83,5 +85,5 @@ class DeploymentConversationEvent(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'role': self.role, 'text': self.text, 'timestamp': self.timestamp, 'message_index': self.message_index, 'regenerate_attempt': self.regenerate_attempt, 'model_version': self.model_version, 'search_results': self.search_results, 'is_useful': self.is_useful, 'feedback': self.feedback, 'feedback_type': self.feedback_type, 'doc_infos': self.doc_infos, 'keyword_arguments': self.keyword_arguments, 'input_params': self.input_params, 'attachments': self.attachments, 'response_version': self.response_version,
-                'agent_workflow_node_id': self.agent_workflow_node_id, 'next_agent_workflow_node_id': self.next_agent_workflow_node_id, 'chat_type': self.chat_type, 'agent_response': self.agent_response, 'error': self.error, 'segments': self.segments, 'streamed_data': self.streamed_data, 'streamed_section_data': self.streamed_section_data, 'highlights': self.highlights, 'llm_display_name': self.llm_display_name, 'llm_bot_icon': self.llm_bot_icon, 'form_response': self.form_response}
+                'agent_workflow_node_id': self.agent_workflow_node_id, 'next_agent_workflow_node_id': self.next_agent_workflow_node_id, 'chat_type': self.chat_type, 'agent_response': self.agent_response, 'error': self.error, 'segments': self.segments, 'streamed_data': self.streamed_data, 'streamed_section_data': self.streamed_section_data, 'highlights': self.highlights, 'llm_display_name': self.llm_display_name, 'llm_bot_icon': self.llm_bot_icon, 'form_response': self.form_response, 'routed_llm': self.routed_llm}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/document_retriever_config.py

@@ -14,9 +14,11 @@ class DocumentRetrieverConfig(AbstractApiClass):
             scoreMultiplierColumn (str): The values in this metadata column are used to modify the relevance scores of returned chunks.
             pruneVectors (bool): Corpus specific transformation of vectors that applies dimensional reduction techniques to strip common components from the vectors.
             indexMetadataColumns (bool): If True, metadata columns of the FG will also be used for indexing and querying.
+            useDocumentSummary (bool): If True, uses the summary of the document in addition to chunks of the document for indexing and querying.
+            summaryInstructions (str): Instructions for the LLM to generate the document summary.
     """
 
-    def __init__(self, client, chunkSize=None, chunkOverlapFraction=None, textEncoder=None, scoreMultiplierColumn=None, pruneVectors=None, indexMetadataColumns=None):
+    def __init__(self, client, chunkSize=None, chunkOverlapFraction=None, textEncoder=None, scoreMultiplierColumn=None, pruneVectors=None, indexMetadataColumns=None, useDocumentSummary=None, summaryInstructions=None):
         super().__init__(client, None)
         self.chunk_size = chunkSize
         self.chunk_overlap_fraction = chunkOverlapFraction
@@ -24,11 +26,13 @@ class DocumentRetrieverConfig(AbstractApiClass):
         self.score_multiplier_column = scoreMultiplierColumn
         self.prune_vectors = pruneVectors
         self.index_metadata_columns = indexMetadataColumns
+        self.use_document_summary = useDocumentSummary
+        self.summary_instructions = summaryInstructions
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'chunk_size': repr(self.chunk_size), f'chunk_overlap_fraction': repr(self.chunk_overlap_fraction), f'text_encoder': repr(self.text_encoder), f'score_multiplier_column': repr(
-            self.score_multiplier_column), f'prune_vectors': repr(self.prune_vectors), f'index_metadata_columns': repr(self.index_metadata_columns)}
+        repr_dict = {f'chunk_size': repr(self.chunk_size), f'chunk_overlap_fraction': repr(self.chunk_overlap_fraction), f'text_encoder': repr(self.text_encoder), f'score_multiplier_column': repr(self.score_multiplier_column), f'prune_vectors': repr(
+            self.prune_vectors), f'index_metadata_columns': repr(self.index_metadata_columns), f'use_document_summary': repr(self.use_document_summary), f'summary_instructions': repr(self.summary_instructions)}
         class_name = "DocumentRetrieverConfig"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
@@ -41,6 +45,6 @@ class DocumentRetrieverConfig(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'chunk_size': self.chunk_size, 'chunk_overlap_fraction': self.chunk_overlap_fraction, 'text_encoder': self.text_encoder,
-                'score_multiplier_column': self.score_multiplier_column, 'prune_vectors': self.prune_vectors, 'index_metadata_columns': self.index_metadata_columns}
+        resp = {'chunk_size': self.chunk_size, 'chunk_overlap_fraction': self.chunk_overlap_fraction, 'text_encoder': self.text_encoder, 'score_multiplier_column': self.score_multiplier_column,
+                'prune_vectors': self.prune_vectors, 'index_metadata_columns': self.index_metadata_columns, 'use_document_summary': self.use_document_summary, 'summary_instructions': self.summary_instructions}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

abacusai-1.4.17/abacusai/regenerate_llm_external_application.py

@@ -0,0 +1,37 @@
+from .return_class import AbstractApiClass
+
+
+class RegenerateLlmExternalApplication(AbstractApiClass):
+    """
+        An external application that specifies an LLM user can regenerate with in RouteLLM.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            name (str): The external name of the LLM.
+            externalApplicationId (str): The unique identifier of the external application.
+    """
+
+    def __init__(self, client, name=None, externalApplicationId=None):
+        super().__init__(client, None)
+        self.name = name
+        self.external_application_id = externalApplicationId
+        self.deprecated_keys = {}
+
+    def __repr__(self):
+        repr_dict = {f'name': repr(self.name), f'external_application_id': repr(
+            self.external_application_id)}
+        class_name = "RegenerateLlmExternalApplication"
+        repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
+        ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
+        return f"{class_name}({repr_str})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        resp = {'name': self.name,
+                'external_application_id': self.external_application_id}
+        return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai/workflow_node_template.py

@@ -15,12 +15,13 @@ class WorkflowNodeTemplate(AbstractApiClass):
             description (str): A description of the workflow node template.
             packageRequirements (list[str]): A list of package requirements that the node source code may need.
             tags (dict): Tags to add to the workflow node template. It contains information on the intended usage of template.
+            additionalConfigs (dict): Additional configurations for the workflow node template.
             inputs (WorkflowNodeTemplateInput): A list of inputs that the workflow node template will use.
             outputs (WorkflowNodeTemplateOutput): A list of outputs that the workflow node template will give.
             templateConfigs (WorkflowNodeTemplateConfig): A list of template configs that are hydrated into source to get complete code.
     """
 
-    def __init__(self, client, workflowNodeTemplateId=None, name=None, functionName=None, sourceCode=None, description=None, packageRequirements=None, tags=None, inputs={}, outputs={}, templateConfigs={}):
+    def __init__(self, client, workflowNodeTemplateId=None, name=None, functionName=None, sourceCode=None, description=None, packageRequirements=None, tags=None, additionalConfigs=None, inputs={}, outputs={}, templateConfigs={}):
         super().__init__(client, workflowNodeTemplateId)
         self.workflow_node_template_id = workflowNodeTemplateId
         self.name = name
@@ -29,6 +30,7 @@ class WorkflowNodeTemplate(AbstractApiClass):
         self.description = description
         self.package_requirements = packageRequirements
         self.tags = tags
+        self.additional_configs = additionalConfigs
         self.inputs = client._build_class(WorkflowNodeTemplateInput, inputs)
         self.outputs = client._build_class(WorkflowNodeTemplateOutput, outputs)
         self.template_configs = client._build_class(
@@ -36,8 +38,8 @@ class WorkflowNodeTemplate(AbstractApiClass):
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'workflow_node_template_id': repr(self.workflow_node_template_id), f'name': repr(self.name), f'function_name': repr(self.function_name), f'source_code': repr(self.source_code), f'description': repr(
-            self.description), f'package_requirements': repr(self.package_requirements), f'tags': repr(self.tags), f'inputs': repr(self.inputs), f'outputs': repr(self.outputs), f'template_configs': repr(self.template_configs)}
+        repr_dict = {f'workflow_node_template_id': repr(self.workflow_node_template_id), f'name': repr(self.name), f'function_name': repr(self.function_name), f'source_code': repr(self.source_code), f'description': repr(self.description), f'package_requirements': repr(
+            self.package_requirements), f'tags': repr(self.tags), f'additional_configs': repr(self.additional_configs), f'inputs': repr(self.inputs), f'outputs': repr(self.outputs), f'template_configs': repr(self.template_configs)}
         class_name = "WorkflowNodeTemplate"
         repr_str = ',\n  '.join([f'{key}={value}' for key, value in repr_dict.items(
         ) if getattr(self, key, None) is not None and key not in self.deprecated_keys])
@@ -51,5 +53,5 @@ class WorkflowNodeTemplate(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'workflow_node_template_id': self.workflow_node_template_id, 'name': self.name, 'function_name': self.function_name, 'source_code': self.source_code, 'description': self.description, 'package_requirements': self.package_requirements,
-                'tags': self.tags, 'inputs': self._get_attribute_as_dict(self.inputs), 'outputs': self._get_attribute_as_dict(self.outputs), 'template_configs': self._get_attribute_as_dict(self.template_configs)}
+                'tags': self.tags, 'additional_configs': self.additional_configs, 'inputs': self._get_attribute_as_dict(self.inputs), 'outputs': self._get_attribute_as_dict(self.outputs), 'template_configs': self._get_attribute_as_dict(self.template_configs)}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.15 → abacusai-1.4.17/abacusai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abacusai
-Version: 1.4.15
+Version: 1.4.17
 Summary: Abacus.AI Python Client Library
 Home-page: https://github.com/abacusai/api-python
 Author: Abacus.AI

{abacusai-1.4.15 → abacusai-1.4.17}/abacusai.egg-info/SOURCES.txt

@@ -202,6 +202,7 @@ abacusai/realtime_monitor.py
 abacusai/refresh_pipeline_run.py
 abacusai/refresh_policy.py
 abacusai/refresh_schedule.py
+abacusai/regenerate_llm_external_application.py
 abacusai/requirements.txt
 abacusai/resolved_feature_group_template.py
 abacusai/return_class.py

{abacusai-1.4.15 → abacusai-1.4.17}/docs/.buildinfo.bak

@@ -1,4 +1,4 @@
 # Sphinx build info version 1
 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 29cf0b9064b2c084484177223531079b
+config: 12535596649b36dd1c7e0cddf2d1e3b2
 tags: 645f666f9bcd5a90fca523b33c5a78b7

{abacusai-1.4.15 → abacusai-1.4.17}/docs/_sources/autoapi/abacusai/agent/index.rst.txt

@@ -146,6 +146,24 @@ Module Contents
 
 
 
+   .. py:property:: description
+      :type: str
+
+      The description of the agent.
+
+
+   .. py:property:: agent_interface
+      :type: str
+
+      The interface that the agent will be deployed with.
+
+
+   .. py:property:: agent_connectors
+      :type: dict
+
+      A dictionary mapping ApplicationConnectorType keys to lists of OAuth scopes. Each key represents a specific application connector, while the value is a list of scopes that define the permissions granted to the application.
+
+
    .. py:method:: wait_for_publish(timeout=None)
 
       A waiting call until agent is published.