abacusai 1.4.3__tar.gz → 1.4.4__tar.gz

{abacusai-1.4.3/abacusai.egg-info → abacusai-1.4.4}/PKG-INFO

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

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/__init__.py

@@ -4,4 +4,4 @@ from .prediction_client import PredictionClient
 from .streaming_client import StreamingClient
 
 
-__version__ = "1.4.3"
+__version__ = "1.4.4"

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/api_class/ai_agents.py

@@ -126,7 +126,7 @@ class WorkflowNodeInputMapping(ApiClass):
     def to_dict(self):
         return {
             'name': self.name,
-            'variable_type': self.variable_type,
+            'variable_type': self.variable_type.value,
             'variable_source': self.variable_source,
             'is_required': self.is_required
         }
@@ -139,7 +139,7 @@ class WorkflowNodeInputMapping(ApiClass):
             raise ValueError('input_mapping', f'Invalid workflow node input mapping "{mapping}". Must contain keys - name, variable_type')
         return cls(
             name=mapping['name'],
-            variable_type=mapping['variable_type'],
+            variable_type=enums.WorkflowNodeInputType(mapping['variable_type']),
             variable_source=mapping.get('variable_source'),
             is_required=mapping.get('is_required', True)
         )
@@ -160,7 +160,7 @@ class WorkflowNodeOutputMapping(ApiClass):
     def to_dict(self):
         return {
             'name': self.name,
-            'variable_type': self.variable_type
+            'variable_type': self.variable_type.value
         }
 
     @classmethod
@@ -171,7 +171,7 @@ class WorkflowNodeOutputMapping(ApiClass):
             raise ValueError('output_mapping', 'Invalid workflow node output mapping. Must contain keys - name.')
         return cls(
             name=mapping['name'],
-            variable_type=mapping.get('variable_type', enums.WorkflowNodeOutputType.STRING)
+            variable_type=enums.WorkflowNodeOutputType(mapping.get('variable_type', 'STRING'))
         )
 
 

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/api_class/enums.py

@@ -422,6 +422,7 @@ class PythonFunctionOutputArgumentType(ApiEnum):
 class VectorStoreTextEncoder(ApiEnum):
     E5 = 'E5'
     OPENAI = 'OPENAI'
+    OPENAI_LARGE = 'OPENAI_LARGE'
     SENTENCE_BERT = 'SENTENCE_BERT'
     E5_SMALL = 'E5_SMALL'
     CODE_BERT = 'CODE_BERT'
@@ -432,28 +433,19 @@ class LLMName(ApiEnum):
     OPENAI_GPT4_32K = 'OPENAI_GPT4_32K'
     OPENAI_GPT4_128K = 'OPENAI_GPT4_128K'
     OPENAI_GPT4_128K_LATEST = 'OPENAI_GPT4_128K_LATEST'
-    OPENAI_GPT4_VISION = 'OPENAI_GPT4_VISION'
     OPENAI_GPT4O = 'OPENAI_GPT4O'
     OPENAI_GPT4O_MINI = 'OPENAI_GPT4O_MINI'
     OPENAI_GPT3_5 = 'OPENAI_GPT3_5'
     OPENAI_GPT3_5_TEXT = 'OPENAI_GPT3_5_TEXT'
     LLAMA3_1_405B = 'LLAMA3_1_405B'
+    LLAMA3_1_70B = 'LLAMA3_1_70B'
+    LLAMA3_1_8B = 'LLAMA3_1_8B'
     LLAMA3_LARGE_CHAT = 'LLAMA3_LARGE_CHAT'
-    GROQ_LLAMA3_LARGE_CHAT = 'GROQ_LLAMA3_LARGE_CHAT'
-    CLAUDE_V2_1 = 'CLAUDE_V2_1'
     CLAUDE_V3_OPUS = 'CLAUDE_V3_OPUS'
     CLAUDE_V3_SONNET = 'CLAUDE_V3_SONNET'
     CLAUDE_V3_HAIKU = 'CLAUDE_V3_HAIKU'
     CLAUDE_V3_5_SONNET = 'CLAUDE_V3_5_SONNET'
-    ABACUS_GIRAFFE = 'ABACUS_GIRAFFE'
-    ABACUS_GIRAFFE_LARGE = 'ABACUS_GIRAFFE_LARGE'
-    LLAMA2_CHAT = 'LLAMA2_CHAT'
-    PALM = 'PALM'
-    PALM_TEXT = 'PALM_TEXT'
-    GEMINI_PRO = 'GEMINI_PRO'
     GEMINI_1_5_PRO = 'GEMINI_1_5_PRO'
-    MIXTRAL_CHAT = 'MIXTRAL_CHAT'
-    MISTRAL_MEDIUM = 'MISTRAL_MEDIUM'
     ABACUS_SMAUG3 = 'ABACUS_SMAUG3'
     GEMINI_1_5_FLASH = 'GEMINI_1_5_FLASH'
 

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/api_class/model.py

@@ -460,8 +460,8 @@ class ChatLLMTrainingConfig(TrainingConfig):
         filter_columns (list): Allow users to filter the document retrievers on these metadata columns.
         include_general_knowledge (bool): Allow the LLM to rely not just on RAG search results, but to fall back on general knowledge. Disabled by default.
         enable_web_search (bool) : Allow the LLM to use Web Search Engines to retrieve information for better results.
-        behavior_instructions (str): Customize the overall role instructions for the LLM.
-        response_instructions (str): Customized instructions for how the LLM should respond.
+        behavior_instructions (str): Customize the overall behaviour of the model. This controls things like - when to execute code (if enabled), write sql query, search web (if enabled), etc.
+        response_instructions (str): Customized instructions for how the model should respond.
         enable_llm_rewrite (bool): If enabled, an LLM will rewrite the RAG queries sent to document retriever. Disabled by default.
         column_filtering_instructions (str): Instructions for a LLM call to automatically generate filter expressions on document metadata to retrieve relevant documents for the conversation.
         keyword_requirement_instructions (str): Instructions for a LLM call to automatically generate keyword requirements to retrieve relevant documents for the conversation.
@@ -469,6 +469,7 @@ class ChatLLMTrainingConfig(TrainingConfig):
         max_search_results (int): Maximum number of search results in the retrieval augmentation step. If we know that the questions are likely to have snippets which are easily matched in the documents, then a lower number will help with accuracy.
         data_feature_group_ids: (List[str]): List of feature group IDs to use to possibly query for the ChatLLM. The created ChatLLM is commonly referred to as DataLLM.
         data_prompt_context (str): Prompt context for the data feature group IDs.
+        data_prompt_table_context (Dict[str, str]): Dict of table name and table context pairs to provide table wise context for each structured data table.
         hide_sql_and_code (bool): When running data queries, this will hide the generated SQL and Code in the response.
         disable_data_summarization (bool): After executing a query summarize the reponse and reply back with only the table and query run.
         data_columns_to_ignore (List[str]): Columns to ignore while encoding information about structured data tables in context for the LLM. A list of strings of format "<table_name>.<column_name>"
@@ -478,6 +479,7 @@ class ChatLLMTrainingConfig(TrainingConfig):
         database_connector_tables (List[str]): List of tables to use from the database connector for the ChatLLM.
         enable_code_execution (bool): Enable python code execution in the ChatLLM. This equips the LLM with a python kernel in which all its code is executed.
         enable_response_caching (bool): Enable caching of LLM responses to speed up response times and improve reproducibility.
+        unknown_answer_phrase (str): Fallback response when the LLM can't find an answer.
     """
     document_retrievers: List[str] = dataclasses.field(default=None)
     num_completion_tokens: int = dataclasses.field(default=None)
@@ -495,6 +497,7 @@ class ChatLLMTrainingConfig(TrainingConfig):
     max_search_results: int = dataclasses.field(default=None)
     data_feature_group_ids: List[str] = dataclasses.field(default=None)
     data_prompt_context: str = dataclasses.field(default=None)
+    data_prompt_table_context: Dict[str, str] = dataclasses.field(default=None)
     hide_sql_and_code: bool = dataclasses.field(default=None)
     disable_data_summarization: bool = dataclasses.field(default=None)
     data_columns_to_ignore: List[str] = dataclasses.field(default=None)
@@ -506,6 +509,7 @@ class ChatLLMTrainingConfig(TrainingConfig):
     metadata_columns: list = dataclasses.field(default=None, metadata={'deprecated': True})
     lookup_rewrite_instructions: str = dataclasses.field(default=None, metadata={'deprecated': True})
     enable_response_caching: bool = dataclasses.field(default=None)
+    unknown_answer_phrase: str = dataclasses.field(default=None)
 
     def __post_init__(self):
         self.problem_type = enums.ProblemType.CHAT_LLM

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/api_client_utils.py

@@ -180,6 +180,194 @@ def load_as_pandas_from_avro_files(files: List[str], download_method: Callable,
     return data_df
 
 
+def validate_workflow_node_inputs(nodes_info, agent_workflow_node_id, keyword_arguments: dict, sample_user_inputs: dict, filtered_workflow_vars: dict):
+    from .api_class import WorkflowNodeInputType
+    input_mappings = nodes_info[agent_workflow_node_id].get(
+        'input_mappings', {})
+    input_schema = nodes_info[agent_workflow_node_id].get('input_schema', {})
+    if input_schema.get('runtime_schema', False):
+        keyword_arguments = {input_schema.get(
+            'schema_prop'): keyword_arguments}
+    for input_mapping in input_mappings:
+        input_name = input_mapping['name']
+        variable_type = input_mapping['variable_type']
+        is_required = input_mapping.get('is_required', True)
+        variable_source = input_mapping['variable_source']
+        if variable_type == 'WORKFLOW_VARIABLE':
+            if variable_source not in filtered_workflow_vars:
+                raise ValueError(
+                    f'The stage corresponding to "{agent_workflow_node_id}" requires variables from {variable_source} stage which are not there.')
+            if input_name not in filtered_workflow_vars[variable_source] and is_required:
+                raise ValueError(
+                    f'Missing required input "{input_name}" in workflow vars for workflow node "{agent_workflow_node_id}".')
+            else:
+                keyword_arguments[input_name] = filtered_workflow_vars[variable_source][input_name]
+        elif variable_type == WorkflowNodeInputType.USER_INPUT:
+            if sample_user_inputs and input_name in sample_user_inputs:
+                keyword_arguments[input_name] = sample_user_inputs[input_name]
+            elif variable_source in filtered_workflow_vars and input_name in filtered_workflow_vars[variable_source]:
+                keyword_arguments[input_name] = filtered_workflow_vars[variable_source][input_name]
+            else:
+                if is_required:
+                    raise ValueError(
+                        f'User input for "{input_name}" is required for the "{agent_workflow_node_id}" node.')
+                else:
+                    keyword_arguments[input_name] = None
+
+
+def run(nodes: List[dict], primary_start_node: str, graph_info: dict, sample_user_inputs: dict = None, agent_workflow_node_id: str = None, workflow_vars: dict = {}, topological_dfs_stack: List = []):
+    from .api_class import WorkflowNodeInputType
+    source_code = graph_info['source_code']
+    exec(source_code, globals())
+
+    nodes_info: dict = {node['name']: node for node in nodes}
+    traversal_orders = graph_info['traversal_orders']
+    nodes_ancestors = graph_info['nodes_ancestors']
+    nodes_inedges = graph_info['nodes_inedges']
+    primary_start_node = primary_start_node or graph_info['default_root_node']
+
+    primary_traversal_order = traversal_orders[primary_start_node]
+    run_info = {}
+    workflow_vars = workflow_vars.copy()
+    next_agent_workflow_node_id = None
+
+    if agent_workflow_node_id:
+        next_agent_workflow_node_id = agent_workflow_node_id
+        if next_agent_workflow_node_id not in traversal_orders.keys():
+            if next_agent_workflow_node_id not in nodes_info:
+                raise ValueError(
+                    f'The provided workflow node id "{next_agent_workflow_node_id}" is not part of the workflow. Please provide a valid node id.')
+            else:
+                topological_dfs_stack.append(next_agent_workflow_node_id)
+        else:
+            topological_dfs_stack = [next_agent_workflow_node_id]
+    else:
+        next_agent_workflow_node_id = primary_start_node
+        topological_dfs_stack = [primary_start_node]
+
+    flow_traversal_order = primary_traversal_order
+    for root, traversal_order in traversal_orders.items():
+        if next_agent_workflow_node_id in traversal_order:
+            flow_traversal_order = traversal_order
+            break
+
+    run_history = []
+    workflow_node_outputs = {}
+    while (True):
+        agent_workflow_node_id = next_agent_workflow_node_id
+        node_ancestors = nodes_ancestors[agent_workflow_node_id]
+
+        # To ensure the node takes inputs only from it's ancestors.
+        # workflow_vars must always contain an entry for ancestor, the error is somewhere else if this ever errors out.
+        filtered_workflow_vars = {}
+        for ancestor in node_ancestors:
+            if ancestor not in workflow_vars:
+                raise ValueError(
+                    f'Ancestor "{ancestor}" of node "{agent_workflow_node_id}" is not executed yet. Please make sure the ancestor nodes are executed before the current node.')
+            else:
+                filtered_workflow_vars[ancestor] = workflow_vars[ancestor]
+
+        arguments = []
+        keyword_arguments = {}
+        validate_workflow_node_inputs(nodes_info, agent_workflow_node_id,
+                                      keyword_arguments, sample_user_inputs, filtered_workflow_vars)
+
+        try:
+            func = eval(nodes_info[agent_workflow_node_id]['function_name'])
+            node_response = func(*arguments, **keyword_arguments)
+            workflow_node_outputs[agent_workflow_node_id] = node_response.to_dict(
+            )
+            node_workflow_vars = process_node_response(node_response)
+        except Exception as error:
+            raise ValueError(
+                f'Error in running workflow node {agent_workflow_node_id}: {error}')
+
+        workflow_vars[agent_workflow_node_id] = node_workflow_vars
+        next_agent_workflow_node_id = None
+        needs_user_input = False
+
+        potential_next_index = flow_traversal_order.index(
+            topological_dfs_stack[-1]) + 1
+        potential_next_agent_workflow_node_id = None
+        while (potential_next_index < len(flow_traversal_order)):
+            potential_next_agent_workflow_node_id = flow_traversal_order[potential_next_index]
+            incoming_edges = nodes_inedges[potential_next_agent_workflow_node_id]
+            valid_next_node = True
+            for source, _, details in incoming_edges:
+                if source not in topological_dfs_stack:
+                    valid_next_node = False
+                    potential_next_index += 1
+                    break
+                else:
+                    edge_evaluate_result = evaluate_edge_condition(
+                        source, potential_next_agent_workflow_node_id, details, workflow_vars)
+                    if not edge_evaluate_result:
+                        valid_next_node = False
+                        potential_next_index += 1
+                        break
+            if valid_next_node:
+                next_agent_workflow_node_id = potential_next_agent_workflow_node_id
+                break
+
+        if next_agent_workflow_node_id:
+            next_node_input_mappings = nodes_info[next_agent_workflow_node_id].get(
+                'input_mappings', [])
+            needs_user_input = any([input_mapping['variable_type'] ==
+                                   WorkflowNodeInputType.USER_INPUT for input_mapping in next_node_input_mappings])
+
+        if needs_user_input:
+            run_history.append(
+                f'Workflow node {agent_workflow_node_id} completed with next node {next_agent_workflow_node_id} and needs user_inputs')
+        else:
+            run_history.append(
+                f'Workflow node {agent_workflow_node_id} completed with next node {next_agent_workflow_node_id}')
+            topological_dfs_stack.append(next_agent_workflow_node_id)
+
+        if next_agent_workflow_node_id is None or needs_user_input:
+            break
+
+    run_info['workflow_node_outputs'] = workflow_node_outputs
+    run_info['run_history'] = run_history
+
+    workflow_info = {}
+    workflow_info['workflow_vars'] = workflow_vars
+    workflow_info['topological_dfs_stack'] = topological_dfs_stack
+    workflow_info['run_info'] = run_info
+
+    return workflow_info
+
+
+def evaluate_edge_condition(source, target, details, workflow_vars):
+    try:
+        condition = details.get('EXECUTION_CONDITION')
+        if condition:
+            result = execute_python_source(
+                condition, workflow_vars.get(source, {}))
+            return result
+        return True
+    except Exception as e:
+        raise ValueError(
+            f"Error evaluating edge '{source}'-->'{target}': {str(e)}")
+
+
+def execute_python_source(python_expression, variables):
+    try:
+        # Evaluate the expression using the variables dictionary
+        result = eval(python_expression, {}, variables)
+        return result
+    except Exception as e:
+        # Handle any exceptions that may occur during evaluation
+        raise ValueError(f'Error evaluating expression: {e}')
+
+
+def process_node_response(node_response):
+    output_vars = {}
+    for variable in node_response.section_data_list:
+        for key, value in variable.items():
+            output_vars[key] = value
+    return output_vars
+
+
 class StreamType(Enum):
     MESSAGE = 'message'
     SECTION_OUTPUT = 'section_output'

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/client.py

@@ -47,10 +47,11 @@ from .api_class import (
 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.blob_input import Blob, BlobInput
+from .api_class.enums import AgentInterface
 from .api_class.segments import ResponseSection, Segment
 from .api_client_utils import (
     INVALID_PANDAS_COLUMN_NAME_CHARACTERS, StreamingHandler, StreamType,
-    clean_column_name, get_object_from_context
+    clean_column_name, get_object_from_context, run
 )
 from .api_endpoint import ApiEndpoint
 from .api_key import ApiKey
@@ -272,14 +273,22 @@ class AgentResponse:
                 self.data_list.append(arg)
             else:
                 raise Exception(
-                    'AgentResponse can only contain Blob, ResponseSection or json serializable objects')
+                    'AgentResponse can only contain Blob, ResponseSection or json serializable objects if key is not provided')
 
         for key, value in kwargs.items():
-            if isinstance(value, Blob) or _is_json_serializable(value) or isinstance(value, (ResponseSection, Segment)):
-                self.section_data_list.append({key: value})
-            else:
-                raise Exception(
-                    'AgentResponse can only contain Blob, ResponseSection or json serializable objects')
+            self.section_data_list.append({key: value})
+
+    def to_dict(self):
+        result = {}
+        if self.data_list:
+            result['data_list'] = self.data_list
+        for section_data in self.section_data_list:
+            for k, v in section_data.items():
+                if isinstance(v, ResponseSection):
+                    result[k] = v.to_dict()
+                else:
+                    result[k] = v
+        return result
 
 
 class ClientOptions:
@@ -595,7 +604,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.3'
+    client_version = '1.4.4'
 
     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
@@ -3520,6 +3529,32 @@ class ApiClient(ReadOnlyClient):
             setattr(the_main, name, getattr(module, name))
         return module
 
+    def run_workflow_graph(self, workflow_graph: WorkflowGraph, sample_user_inputs: dict = {}, agent_workflow_node_id: str = None, agent_interface: AgentInterface = AgentInterface.DEFAULT, package_requirements: list = []):
+        """
+        Validates the workflow graph for an AI Agent.
+
+        Args:
+            workflow_graph (WorkflowGraph): The workflow graph to validate.
+            sample_user_inputs (dict): Contains sample values for variables of type user_input for starting node
+            agent_workflow_node_id (str): Node id from which we want to run workflow
+            agent_interface (AgentInterface): The interface that the agent will be deployed with.
+            package_requirements (list): A list of package requirement strings. For example: ['numpy==1.2.3', 'pandas>=1.4.0'].
+
+        Returns:
+            dict: The output variables for every node in workflow which has executed.
+        """
+        graph_info = self.extract_graph_information(
+            workflow_graph=workflow_graph, agent_interface=agent_interface, package_requirements=package_requirements)
+        workflow_vars = get_object_from_context(
+            self, _request_context, 'workflow_vars', dict) or {}
+        topological_dfs_stack = get_object_from_context(
+            self, _request_context, 'topological_dfs_stack', list) or []
+        workflow_info = run(nodes=workflow_graph['nodes'], primary_start_node=workflow_graph['primary_start_node'], graph_info=graph_info,
+                            sample_user_inputs=sample_user_inputs, agent_workflow_node_id=agent_workflow_node_id, workflow_vars=workflow_vars, topological_dfs_stack=topological_dfs_stack)
+        _request_context.workflow_vars = workflow_info['workflow_vars']
+        _request_context.topological_dfs_stack = workflow_info['topological_dfs_stack']
+        return workflow_info['run_info']
+
     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]
@@ -3883,6 +3918,7 @@ class ApiClient(ReadOnlyClient):
             body['extraArgs'] = extra_args
         headers = {'APIKEY': self.api_key}
         body['connectionId'] = uuid4().hex
+        self._clean_api_objects(body)
         for _ in range(3):
             response = self._request(
                 api_endpont, method='POST', body=body, headers=headers)
@@ -6199,7 +6235,7 @@ Creates a new feature group defined as the union of other feature group versions
         return self._call_api('createPredictionOperator', 'POST', query_params={}, body={'name': name, 'projectId': project_id, 'sourceCode': source_code, 'predictFunctionName': predict_function_name, 'initializeFunctionName': initialize_function_name, 'featureGroupIds': feature_group_ids, 'cpuSize': cpu_size, 'memory': memory, 'packageRequirements': package_requirements, 'useGpu': use_gpu}, parse_type=PredictionOperator)
 
     def update_prediction_operator(self, prediction_operator_id: str, name: str = None, feature_group_ids: List = None, source_code: str = None, initialize_function_name: str = None, predict_function_name: str = None, cpu_size: str = None, memory: int = None, package_requirements: list = None, use_gpu: bool = None) -> PredictionOperator:
-        """Update an existing prediction operator.
+        """Update an existing prediction operator. This does not create a new version.
 
         Args:
             prediction_operator_id (str): The unique ID of the prediction operator.
@@ -8248,6 +8284,14 @@ Creates a new feature group defined as the union of other feature group versions
             Agent: The updated agent."""
         return self._call_api('updateAgent', 'POST', query_params={}, body={'modelId': model_id, 'functionSourceCode': function_source_code, 'agentFunctionName': agent_function_name, 'memory': memory, 'packageRequirements': package_requirements, 'description': description, 'enableBinaryInput': enable_binary_input, 'agentInputSchema': agent_input_schema, 'agentOutputSchema': agent_output_schema, 'workflowGraph': workflow_graph, 'agentInterface': agent_interface, 'includedModules': included_modules}, parse_type=Agent)
 
+    def generate_agent_code(self, project_id: str, prompt: str) -> list:
+        """Generates the code for defining an AI Agent
+
+        Args:
+            project_id (str): The unique ID associated with the project.
+            prompt (str): A natural language prompt which describes agent specification. Describe what the agent will do, what inputs it will expect, and what outputs it will give out"""
+        return self._call_api('generateAgentCode', 'POST', query_params={}, body={'projectId': project_id, 'prompt': prompt})
+
     def evaluate_prompt(self, prompt: str = None, system_message: str = None, llm_name: Union[LLMName, str] = None, max_tokens: int = None, temperature: float = 0.0, messages: list = None, response_type: str = None, json_response_schema: dict = None) -> LlmResponse:
         """Generate response to the prompt using the specified model.
 
@@ -8304,7 +8348,7 @@ Creates a new feature group defined as the union of other feature group versions
 
         Returns:
             ExtractedFields: The response from the document query."""
-        return self._call_api('extractDataUsingLLM', 'POST', query_params={}, body={'fieldDescriptors': field_descriptors, 'documentId': document_id, 'documentText': document_text, 'llmName': llm_name}, parse_type=ExtractedFields)
+        return self._proxy_request('ExtractDataUsingLlm', 'POST', query_params={}, body={'fieldDescriptors': field_descriptors, 'documentId': document_id, 'documentText': document_text, 'llmName': llm_name}, parse_type=ExtractedFields)
 
     def search_web_for_llm(self, queries: List, search_providers: List = None, max_results: int = 1, safe: bool = True, fetch_content: bool = False, max_page_tokens: int = 8192, convert_to_markdown: bool = True) -> WebSearchResponse:
         """Access web search providers to fetch content related to the queries for use in large language model inputs.
@@ -8351,6 +8395,24 @@ Creates a new feature group defined as the union of other feature group versions
             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.
+
+        Args:
+            workflow_graph (WorkflowGraph): The workflow graph to validate.
+            agent_interface (AgentInterface): The interface that the agent will be deployed with.
+            package_requirements (list): A list of package requirement strings. For example: ['numpy==1.2.3', 'pandas>=1.4.0']."""
+        return self._call_api('validateWorkflowGraph', 'POST', query_params={}, body={'workflowGraph': workflow_graph, 'agentInterface': agent_interface, 'packageRequirements': package_requirements})
+
+    def extract_graph_information(self, workflow_graph: Union[dict, WorkflowGraph], agent_interface: Union[AgentInterface, str] = AgentInterface.DEFAULT, package_requirements: list = []) -> dict:
+        """Extracts information from the workflow.
+
+        Args:
+            workflow_graph (WorkflowGraph): The workflow graph to validate.
+            agent_interface (AgentInterface): The interface that the agent will be deployed with.
+            package_requirements (list): A list of package requirement strings. For example: ['numpy==1.2.3', 'pandas>=1.4.0']."""
+        return self._call_api('extractGraphInformation', 'POST', query_params={}, body={'workflowGraph': workflow_graph, 'agentInterface': agent_interface, 'packageRequirements': package_requirements})
+
     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.3 → abacusai-1.4.4}/abacusai/data_upload_result.py

@@ -8,15 +8,18 @@ class DataUploadResult(AbstractApiClass):
         Args:
             client (ApiClient): An authenticated API Client instance
             docInfos (list[agentdatadocumentinfo]): A list of dict for information on the documents uploaded to agent.
+            maxCount (int): The maximum number of documents
     """
 
-    def __init__(self, client, docInfos=None):
+    def __init__(self, client, docInfos=None, maxCount=None):
         super().__init__(client, None)
         self.doc_infos = docInfos
+        self.max_count = maxCount
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'doc_infos': repr(self.doc_infos)}
+        repr_dict = {f'doc_infos': repr(
+            self.doc_infos), f'max_count': repr(self.max_count)}
         class_name = "DataUploadResult"
         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])
@@ -29,5 +32,5 @@ class DataUploadResult(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'doc_infos': self.doc_infos}
+        resp = {'doc_infos': self.doc_infos, 'max_count': self.max_count}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/prediction_operator.py

@@ -95,7 +95,7 @@ class PredictionOperator(AbstractApiClass):
 
     def update(self, name: str = None, feature_group_ids: List = None, source_code: str = None, initialize_function_name: str = None, predict_function_name: str = None, cpu_size: str = None, memory: int = None, package_requirements: list = None, use_gpu: bool = None):
         """
-        Update an existing prediction operator.
+        Update an existing prediction operator. This does not create a new version.
 
         Args:
             name (str): Name of the prediction operator.

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai/project.py

@@ -628,6 +628,15 @@ class Project(AbstractApiClass):
         """
         return self.client.create_agent(self.project_id, function_source_code, agent_function_name, name, memory, package_requirements, description, enable_binary_input, evaluation_feature_group_id, agent_input_schema, agent_output_schema, workflow_graph, agent_interface, included_modules)
 
+    def generate_agent_code(self, prompt: str):
+        """
+        Generates the code for defining an AI Agent
+
+        Args:
+            prompt (str): A natural language prompt which describes agent specification. Describe what the agent will do, what inputs it will expect, and what outputs it will give out
+        """
+        return self.client.generate_agent_code(self.project_id, prompt)
+
     def list_agents(self):
         """
         Retrieves the list of agents in the specified project.

abacusai-1.4.4/abacusai/public.pem

@@ -0,0 +1,5 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIGJAoGBAJLWIpDJp9u04H/KEfu+Tre2FVZ7bCZvsdGKquNOXPK04o8N1l/3GKVs
+jH85NN9pu3jGUc8nb0I02SeYL1TssbH3PeAsxlq/J1LecQe8y0iJpgRfj85CZoPD
+T077y9poEC1q3HbB56rpXwBR+pcqmAvDLsC5d2QKcqIKB2+2WDdtAgMBAAE=
+-----END RSA PUBLIC KEY-----

abacusai-1.4.4/abacusai/tone_details.py

@@ -0,0 +1,49 @@
+from .return_class import AbstractApiClass
+
+
+class ToneDetails(AbstractApiClass):
+    """
+        Tone details for audio
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            voiceId (str): The voice id
+            name (str): The name
+            gender (str): The gender
+            language (str): The language
+            age (str): The age
+            accent (str): The accent
+            useCase (str): The use case
+            description (str): The description
+    """
+
+    def __init__(self, client, voiceId=None, name=None, gender=None, language=None, age=None, accent=None, useCase=None, description=None):
+        super().__init__(client, None)
+        self.voice_id = voiceId
+        self.name = name
+        self.gender = gender
+        self.language = language
+        self.age = age
+        self.accent = accent
+        self.use_case = useCase
+        self.description = description
+        self.deprecated_keys = {}
+
+    def __repr__(self):
+        repr_dict = {f'voice_id': repr(self.voice_id), f'name': repr(self.name), f'gender': repr(self.gender), f'language': repr(
+            self.language), f'age': repr(self.age), f'accent': repr(self.accent), f'use_case': repr(self.use_case), f'description': repr(self.description)}
+        class_name = "ToneDetails"
+        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 = {'voice_id': self.voice_id, 'name': self.name, 'gender': self.gender, 'language': self.language,
+                'age': self.age, 'accent': self.accent, 'use_case': self.use_case, 'description': self.description}
+        return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.3 → abacusai-1.4.4/abacusai.egg-info}/PKG-INFO

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

{abacusai-1.4.3 → abacusai-1.4.4}/abacusai.egg-info/SOURCES.txt

@@ -208,6 +208,7 @@ abacusai/streaming_connector.py
 abacusai/streaming_row_count.py
 abacusai/streaming_sample_code.py
 abacusai/test_point_predictions.py
+abacusai/tone_details.py
 abacusai/training_config_options.py
 abacusai/upload.py
 abacusai/upload_part.py

{abacusai-1.4.3 → abacusai-1.4.4}/docs/_sources/autoapi/abacusai/api_class/dataset/index.rst.txt

@@ -80,6 +80,8 @@ Module Contents
    :type remove_watermarks: bool
    :param convert_to_markdown: Whether to convert extracted text to markdown. Defaults to False. This option only takes effect when extract_bounding_boxes is True.
    :type convert_to_markdown: bool
+   :param mask_pii: Whether to mask personally identifiable information (PII) in the document text/tokens. Defaults to False.
+   :type mask_pii: bool
 
 
    .. py:attribute:: extract_bounding_boxes
@@ -116,6 +118,12 @@ Module Contents
 
 
 
+   .. py:attribute:: mask_pii
+      :type:  bool
+      :value: False
+
+
+
 .. py:class:: DatasetDocumentProcessingConfig
 
    Bases: :py:obj:`DocumentProcessingConfig`