abacusai 1.2.5__tar.gz → 1.2.7__tar.gz

{abacusai-1.2.5/abacusai.egg-info → abacusai-1.2.7}/PKG-INFO

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

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/api_class/abstract.py

@@ -171,20 +171,22 @@ class ApiClass(ABC):
                 input_dict = {snake_case(k): v for k, v in input_dict.items()}
             if not cls._support_kwargs:
                 # only use keys that are valid fields in the ApiClass
-                field_names = set((field.name) for field in dataclasses.fields(cls))
+                field_names = set((field.name) for field in dataclasses.fields(type(obj) if obj else cls))
                 input_dict = {k: v for k, v in input_dict.items() if k in field_names}
         if obj is None:
             obj = cls(**input_dict)
 
-        for attr_name, attr_type in get_type_hints(cls).items():
-            if attr_name in input_dict and inspect.isclass(attr_type) and issubclass(attr_type, ApiClass):
+        for attr_name, attr_type in get_type_hints(type(obj)).items():
+            if attr_name in input_dict and isinstance(input_dict[attr_name], dict) and inspect.isclass(attr_type) and issubclass(attr_type, ApiClass):
                 setattr(obj, attr_name, attr_type.from_dict(input_dict[attr_name]))
             elif attr_name in input_dict and get_origin(attr_type) is list and attr_type.__args__ and inspect.isclass(attr_type.__args__[0]) and issubclass(attr_type.__args__[0], ApiClass):
                 class_type = attr_type.__args__[0]
                 if isinstance(input_dict[attr_name], list):
-                    setattr(obj, attr_name, [class_type.from_dict(item) for item in input_dict[attr_name]])
+                    if not all(isinstance(item, dict) or isinstance(item, class_type) for item in input_dict[attr_name]):
+                        raise ValueError(attr_name, f'Expected list of {class_type} or dictionary for {attr_name}')
+                    setattr(obj, attr_name, [item if isinstance(item, class_type) else class_type.from_dict(item) for item in input_dict[attr_name]])
                 else:
-                    raise ValueError(f'Expected list for {attr_name} but got {type(input_dict[attr_name])}')
+                    raise ValueError(attr_name, f'Expected list for {attr_name} but got {type(input_dict[attr_name])}')
 
         return obj
 
@@ -200,7 +202,7 @@ class _ApiClassFactory(ABC):
         support_kwargs = cls.config_abstract_class and cls.config_abstract_class._support_kwargs
         is_upper_snake_case_keys = cls.config_abstract_class and cls.config_abstract_class._upper_snake_case_keys
         config_class_key = upper_snake_case(cls.config_class_key) if is_upper_snake_case_keys else cls.config_class_key
-        # Logic here is that the we keep the config_class_key in snake_case if _upper_snake_case_keys is False else we convert it to upper_snake_case
+        # Logic here is that the we keep the config_class_key in snake_case if _upper_snake_case_keys False else we convert it to upper_snake_case
         # if _upper_snake_case_keys is False then we check in both casing: 1. snake_case and 2. camel_case
         if not is_upper_snake_case_keys and config_class_key not in config and camel_case(config_class_key) in config:
             config_class_key = camel_case(config_class_key)

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/api_class/ai_agents.py

@@ -28,7 +28,7 @@ class WorkflowNodeInputSchema(ApiClass):
     A react-jsonschema-form conformant schema for workflow node input.
 
     Args:
-        json_schema (dict): The json schema for the input conformant to react-jsonschema-form specification.
+        json_schema (dict): The json schema for the input conformant to react-jsonschema-form specification. Must define keys like "title", "type" and "properties".
         ui_schema (dict): The ui schema for the input conformant to react-jsonschema-form specification.
     """
     json_schema: dict
@@ -76,7 +76,7 @@ class WorkflowNodeInputMapping(ApiClass):
     A mapping of input to a workflow node.
 
     Args:
-        name (str): The name of the input.
+        name (str): The name of the input variable of the node function.
         variable_type (WorkflowNodeInputType): The type of the input.
         variable_source (str): The name of the node this variable is sourced from.
                                If the type is `WORKFLOW_VARIABLE`, the value given by the source node will be directly used.

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/api_class/dataset_application_connector.py

@@ -144,7 +144,12 @@ class SharepointDatasetConfig(DatasetConfig):
 class ZendeskDatasetConfig(DatasetConfig):
     """
     Dataset config for Zendesk Application Connector
+
+    Args:
+        location (str): The regex location of the files to fetch
     """
+    location: str = dataclasses.field(default=None)
+
     def __post_init__(self):
         self.application_connector_type = enums.ApplicationConnectorType.ZENDESK
 

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/api_class/enums.py

@@ -362,6 +362,7 @@ class ApplicationConnectorType(ApiEnum):
     ABACUSUSAGEMETRICS = 'ABACUSUSAGEMETRICS'
     MICROSOFTAUTH = 'MICROSOFTAUTH'
     FRESHSERVICE = 'FRESHSERVICE'
+    ZENDESKSUNSHINEMESSAGING = 'zendesksunshinemessaging'
 
 
 class PythonFunctionArgumentType(ApiEnum):
@@ -412,6 +413,7 @@ class LLMName(ApiEnum):
     OPENAI_GPT3_5 = 'OPENAI_GPT3_5'
     OPENAI_GPT3_5_TEXT = 'OPENAI_GPT3_5_TEXT'
     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'
@@ -541,3 +543,8 @@ class AgentInterface(ApiEnum):
     # Duplicated in reainternal.enums, both should be kept in sync
     DEFAULT = 'DEFAULT'
     CHAT = 'CHAT'
+
+
+class ProjectConfigType(ApiEnum):
+    CONSTRAINTS = 'CONSTRAINTS'
+    REVIEW_MODE = 'REVIEW_MODE'

abacusai-1.2.7/abacusai/api_class/project.py

@@ -0,0 +1,110 @@
+import dataclasses
+from typing import List, Optional
+
+from . import enums
+from .abstract import ApiClass, _ApiClassFactory
+
+
+@dataclasses.dataclass
+class FeatureMappingConfig(ApiClass):
+    """
+    Feature mapping configuration for a feature group type.
+
+    Args:
+        feature_name (str): The name of the feature in the feature group.
+        feature_mapping (str): The desired feature mapping for the feature.
+        nested_feature_name (str): The name of the nested feature in the feature group.
+    """
+    feature_name: str
+    feature_mapping: str = dataclasses.field(default=None)
+    nested_feature_name: str = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class ProjectFeatureGroupTypeMappingsConfig(ApiClass):
+    """
+    Project feature group type mappings.
+
+    Args:
+        feature_group_id (str): The unique identifier for the feature group.
+        feature_group_type (str): The feature group type.
+        feature_mappings (List[FeatureMappingConfig]): The feature mappings for the feature group.
+    """
+    feature_group_id: str
+    feature_group_type: str = dataclasses.field(default=None)
+    feature_mappings: List[FeatureMappingConfig] = dataclasses.field(default=list)
+
+    @classmethod
+    def from_dict(cls, input_dict: dict):
+        inst = cls(**input_dict)
+        inst.feature_mappings = [FeatureMappingConfig.from_dict(fm) for fm in input_dict.get('feature_mappings') or []]
+        return inst
+
+
+@dataclasses.dataclass
+class ConstraintConfig(ApiClass):
+    """
+    Constraint configuration.
+
+    Args:
+        constant (float): The constant value for the constraint.
+        operator (str): The operator for the constraint. Could be 'EQ', 'LE', 'GE'
+        enforcement (str): The enforcement for the constraint. Could be 'HARD' or 'SOFT'
+        code (str): The code for the constraint.
+        penalty (float): The penalty for violating the constraint.
+    """
+    constant: float
+    operator: str
+    enforcement: str
+    code: Optional[str] = dataclasses.field(default=None)
+    penalty: Optional[float] = dataclasses.field(default=None)
+
+
+@dataclasses.dataclass
+class ProjectFeatureGroupConfig(ApiClass):
+    """
+    An abstract class for project feature group configuration.
+    """
+    type: enums.ProjectConfigType = dataclasses.field(default=None, repr=False, init=False)
+
+    @classmethod
+    def _get_builder(cls):
+        return _ProjectFeatureGroupConfigFactory
+
+
+@dataclasses.dataclass
+class ConstraintProjectFeatureGroupConfig(ProjectFeatureGroupConfig):
+    """
+    Constraint project feature group configuration.
+
+    Args:
+        constraints (List[ConstraintConfig]): The constraint for the feature group. Should be a list of one ConstraintConfig.
+    """
+    constraints: List[ConstraintConfig]
+
+    def __post_init__(self):
+        self.type = enums.ProjectConfigType.CONSTRAINTS
+
+
+@dataclasses.dataclass
+class ReviewModeProjectFeatureGroupConfig(ProjectFeatureGroupConfig):
+    """
+    Review mode project feature group configuration.
+
+    Args:
+        is_review_mode (bool): The review mode for the feature group.
+    """
+    is_review_mode: bool
+
+    def __post_init__(self):
+        self.type = enums.ProjectConfigType.REVIEW_MODE
+
+
+@dataclasses.dataclass
+class _ProjectFeatureGroupConfigFactory(_ApiClassFactory):
+    config_abstract_class = ProjectFeatureGroupConfig
+    config_class_key = 'type'
+    config_class_map = {
+        enums.ProjectConfigType.CONSTRAINTS: ConstraintProjectFeatureGroupConfig,
+        enums.ProjectConfigType.REVIEW_MODE: ReviewModeProjectFeatureGroupConfig
+    }

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/api_client_utils.py

@@ -190,6 +190,7 @@ class DocstoreUtils:
     LAST_PAGE = 'last_page'
     PAGE_TEXT = 'page_text'
     PAGES = 'pages'
+    CONTENT = 'content'
     TOKENS = 'tokens'
     PAGES_ZIP_METADATA = 'pages_zip_metadata'
     PAGE_DATA = 'page_data'
@@ -363,9 +364,15 @@ class DocstoreUtils:
                                  for page_no, (h, w) in enumerate(zip(height_list, width_list))]
                 result.update(
                     {cls.TOKENS: tokens, cls.METADATA: metadata_list})
+
             if cls.EXTRACTED_TEXT in group:
-                extracted_text = list(group[cls.EXTRACTED_TEXT])
-                result.update({cls.EXTRACTED_TEXT: extracted_text})
+                pagewise_extracted_text = list(group[cls.EXTRACTED_TEXT])
+                result.update({cls.EXTRACTED_TEXT: pagewise_extracted_text})
+            elif cls.TOKENS in group:
+                pagewise_extracted_text = [' '.join([(token or {}).get(
+                    cls.CONTENT) or '' for token in page_tokens]) for page_tokens in group[cls.TOKENS]]
+                result.update({cls.EXTRACTED_TEXT: pagewise_extracted_text})
+
             return result
 
         doc_infos = pages_df.groupby(doc_id_column).apply(

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/client.py

@@ -38,8 +38,8 @@ from .api_class import (
     DocumentRetrieverConfig, EvalArtifactType, FeatureGroupExportConfig,
     ForecastingMonitorConfig, IncrementalDatabaseConnectorConfig, LLMName,
     MergeConfig, ParsingConfig, PredictionArguments, ProblemType,
-    PythonFunctionType, SamplingConfig, TrainingConfig, WorkflowGraph,
-    get_clean_function_source_code
+    ProjectFeatureGroupConfig, PythonFunctionType, SamplingConfig,
+    TrainingConfig, WorkflowGraph, get_clean_function_source_code
 )
 from .api_class.abstract import get_clean_function_source_code, snake_case
 from .api_class.ai_agents import WorkflowGraph
@@ -199,17 +199,18 @@ async def sse_asynchronous_generator(endpoint: str, body: dict):
         import aiohttp
     except Exception:
         raise Exception('Please install aiohttp to use this functionality')
-    async with aiohttp.ClientSession() as session:
-        async with session.post(endpoint, json=body) as response:
-            async for lines, _ in response.content.iter_chunks():
-                lines = lines.decode('utf-8').split('\n\n')
-                for line in lines:
-                    if line:
-                        line = line.strip()
-                        line = json.loads(line)
-                        line = {snake_case(key): value for key,
-                                value in line.items()}
-                        yield line
+    async with aiohttp.request('POST', endpoint, json=body) as response:
+        async for line in response.content:
+            if line:
+                streamed_responses = line.decode('utf-8').split('\n\n')
+                for resp in streamed_responses:
+                    if resp:
+                        resp = resp.strip()
+                        if resp:
+                            resp = json.loads(resp)
+                            resp = {snake_case(
+                                key): value for key, value in resp.items()}
+                            yield resp
 
 
 def _requests_retry_session(retries=5, backoff_factor=0.1, status_forcelist=(502, 503, 504), session=None, retry_500: bool = False):
@@ -3893,7 +3894,7 @@ class ApiClient(ReadOnlyClient):
 
     def get_matching_documents(self, document_retriever_id: str, query: str, filters: dict = None, limit: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None,
                                max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None,
-                               filter_clause: str = None) -> List[DocumentRetrieverLookupResult]:
+                               filter_clause: str = None, crowding_limits: Dict[str, int] = None) -> List[DocumentRetrieverLookupResult]:
         """Lookup document retrievers and return the matching documents from the document retriever deployed with given query.
 
         Original documents are splitted into chunks and stored in the document retriever. This lookup function will return the relevant chunks
@@ -3914,12 +3915,13 @@ class ApiClient(ReadOnlyClient):
             min_score (float): If provided, will filter out the results with score lower than the value specified.
             required_phrases (list): If provided, each result will have at least one of the phrases.
             filter_clause (str): If provided, filter the results of the query using this sql where clause.
+            crowding_limits (dict): A dictionary mapping metadata columns to the maximum number of results per unique value of the column. This is used to ensure diversity of metadata attribute values in the results. If a particular attribute value has already reached its maximum count, further results with that same attribute value will be excluded from the final result set.
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever."""
 
         deployment_token, deployment_id = self._get_doc_retriever_deployment_info(
             document_retriever_id)
-        return self.lookup_matches(deployment_token, deployment_id, query, filters, limit if limit is not None else 10, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause)
+        return self.lookup_matches(deployment_token, deployment_id, query, filters, limit if limit is not None else 10, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause, crowding_limits)
 
     def create_model_from_files(self, project_id: str, location: str, name: str = None, custom_artifact_filenames: dict = {}, model_config: dict = {}) -> Model:
         """Creates a new Model and returns Upload IDs for uploading the model artifacts.
@@ -3989,7 +3991,7 @@ class ApiClient(ReadOnlyClient):
             filter_key_values (dict): A dictionary mapping column names to a list of values to restrict the retrieved search results.
             search_score_cutoff (float): Cutoff for the document retriever score. Matching search results below this score will be ignored.
             chat_config (dict): A dictionary specifying the query chat config override.
-            ignore_documents (bool): If True, will ignore any documents and search results, and only use the messages to generate a response. 
+            ignore_documents (bool): If True, will ignore any documents and search results, and only use the messages to generate a response.
             include_search_results (bool): If True, will also return search results, if relevant. """
         body = {
             'deploymentToken': deployment_token,
@@ -4305,13 +4307,13 @@ class ApiClient(ReadOnlyClient):
             feature_group_type (str): The feature group type of the feature group, based on the use case under which the feature group is being created."""
         return self._call_api('addFeatureGroupToProject', 'POST', query_params={}, body={'featureGroupId': feature_group_id, 'projectId': project_id, 'featureGroupType': feature_group_type})
 
-    def set_project_feature_group_config(self, feature_group_id: str, project_id: str, project_config: dict = None):
+    def set_project_feature_group_config(self, feature_group_id: str, project_id: str, project_config: Union[dict, ProjectFeatureGroupConfig] = None):
         """Sets a feature group's project config
 
         Args:
             feature_group_id (str): Unique string identifier for the feature group.
             project_id (str): Unique string identifier for the project.
-            project_config (dict): JSON object for the feature group's project configuration."""
+            project_config (ProjectFeatureGroupConfig): Feature group's project configuration."""
         return self._call_api('setProjectFeatureGroupConfig', 'PATCH', query_params={}, body={'featureGroupId': feature_group_id, 'projectId': project_id, 'projectConfig': project_config})
 
     def remove_feature_group_from_project(self, feature_group_id: str, project_id: str):
@@ -5546,19 +5548,20 @@ Creates a new feature group defined as the union of other feature group versions
             PageData: The extracted page data."""
         return self._proxy_request('getDocstorePageData', 'POST', query_params={}, body={'docId': doc_id, 'page': page, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version}, parse_type=PageData, is_sync=True)
 
-    def get_docstore_document_data(self, doc_id: str, document_processing_config: Union[dict, DocumentProcessingConfig] = None, document_processing_version: str = None) -> DocumentData:
+    def get_docstore_document_data(self, doc_id: str, document_processing_config: Union[dict, DocumentProcessingConfig] = None, document_processing_version: str = None, return_extracted_page_text: bool = False) -> DocumentData:
         """Returns the extracted data for a document.
 
         Args:
             doc_id (str): A unique Docstore string identifier for the document.
             document_processing_config (DocumentProcessingConfig): The document processing configuration to use for returning the data. If not provided, the latest available data or the default configuration will be used.
             document_processing_version (str): The document processing version to use for returning the data. If not provided, the latest version will be used.
+            return_extracted_page_text (bool): (Optional) Whether to return list of extracted text for each page.
 
         Returns:
             DocumentData: The extracted document data."""
-        return self._call_api('getDocstoreDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version}, parse_type=DocumentData)
+        return self._call_api('getDocstoreDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': document_processing_config, 'documentProcessingVersion': document_processing_version, 'returnExtractedPageText': return_extracted_page_text}, parse_type=DocumentData)
 
-    def extract_document_data(self, document: io.TextIOBase = None, doc_id: str = None, document_processing_config: Union[dict, DocumentProcessingConfig] = None, start_page: int = None, end_page: int = None) -> DocumentData:
+    def extract_document_data(self, document: io.TextIOBase = None, doc_id: str = None, document_processing_config: Union[dict, DocumentProcessingConfig] = None, start_page: int = None, end_page: int = None, return_extracted_page_text: bool = False) -> DocumentData:
         """Extracts data from a document.
 
         Args:
@@ -5567,10 +5570,11 @@ Creates a new feature group defined as the union of other feature group versions
             document_processing_config (DocumentProcessingConfig): The document processing configuration.
             start_page (int): (Optional) The starting page to extract data from. Pages are indexed starting from 0. If not provided, the first page will be used.
             end_page (int): (Optional) The last page to extract data from. Pages are indexed starting from 0. If not provided, the last page will be used.
+            return_extracted_page_text (bool): (Optional) Whether to return list of extracted text for each page.
 
         Returns:
             DocumentData: The extracted document data."""
-        return self._proxy_request('ExtractDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': json.dumps(document_processing_config), 'startPage': start_page, 'endPage': end_page}, files={'document': document}, parse_type=DocumentData)
+        return self._proxy_request('ExtractDocumentData', 'POST', query_params={}, body={'docId': doc_id, 'documentProcessingConfig': json.dumps(document_processing_config), 'startPage': start_page, 'endPage': end_page, 'returnExtractedPageText': return_extracted_page_text}, files={'document': document}, parse_type=DocumentData)
 
     def get_training_config_options(self, project_id: str, feature_group_ids: List = None, for_retrain: bool = False, current_training_config: Union[dict, TrainingConfig] = None) -> List[TrainingConfigOptions]:
         """Retrieves the full initial description of the model training configuration options available for the specified project. The configuration options available are determined by the use case associated with the specified project. Refer to the [Use Case Documentation]({USE_CASES_URL}) for more information on use cases and use case-specific configuration options.
@@ -7077,7 +7081,7 @@ Creates a new feature group defined as the union of other feature group versions
             deployment_id, deployment_token) if deployment_token else None
         return self._call_api('executeConversationAgent', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'arguments': arguments, 'keywordArguments': keyword_arguments, 'deploymentConversationId': deployment_conversation_id, 'externalSessionId': external_session_id, 'regenerate': regenerate, 'docInfos': doc_infos}, server_override=prediction_url)
 
-    def lookup_matches(self, deployment_token: str, deployment_id: str, data: str = None, filters: dict = None, num: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None, max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None, filter_clause: str = None) -> List[DocumentRetrieverLookupResult]:
+    def lookup_matches(self, deployment_token: str, deployment_id: str, data: str = None, filters: dict = None, num: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None, max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None, filter_clause: str = None, crowding_limits: Dict = None) -> List[DocumentRetrieverLookupResult]:
         """Lookup document retrievers and return the matching documents from the document retriever deployed with given query.
 
         Original documents are splitted into chunks and stored in the document retriever. This lookup function will return the relevant chunks
@@ -7099,12 +7103,13 @@ Creates a new feature group defined as the union of other feature group versions
             min_score (float): If provided, will filter out the results with score less than the value specified.
             required_phrases (list): If provided, each result will contain at least one of the phrases in the given list. The matching is whitespace and case insensitive.
             filter_clause (str): If provided, filter the results of the query using this sql where clause.
+            crowding_limits (Dict): A dictionary mapping metadata columns to the maximum number of results per unique value of the column. This is used to ensure diversity of metadata attribute values in the results. If a particular attribute value has already reached its maximum count, further results with that same attribute value will be excluded from the final result set.
 
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever."""
         prediction_url = self._get_prediction_endpoint(
             deployment_id, deployment_token) if deployment_token else None
-        return self._call_api('lookupMatches', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'data': data, 'filters': filters, 'num': num, 'resultColumns': result_columns, 'maxWords': max_words, 'numRetrievalMarginWords': num_retrieval_margin_words, 'maxWordsPerChunk': max_words_per_chunk, 'scoreMultiplierColumn': score_multiplier_column, 'minScore': min_score, 'requiredPhrases': required_phrases, 'filterClause': filter_clause}, parse_type=DocumentRetrieverLookupResult, server_override=prediction_url)
+        return self._call_api('lookupMatches', 'POST', query_params={'deploymentToken': deployment_token, 'deploymentId': deployment_id}, body={'data': data, 'filters': filters, 'num': num, 'resultColumns': result_columns, 'maxWords': max_words, 'numRetrievalMarginWords': num_retrieval_margin_words, 'maxWordsPerChunk': max_words_per_chunk, 'scoreMultiplierColumn': score_multiplier_column, 'minScore': min_score, 'requiredPhrases': required_phrases, 'filterClause': filter_clause, 'crowdingLimits': crowding_limits}, parse_type=DocumentRetrieverLookupResult, server_override=prediction_url)
 
     def execute_agent_with_binary_data(self, deployment_token: str, deployment_id: str, arguments: list = None, keyword_arguments: dict = None, deployment_conversation_id: str = None, external_session_id: str = None, blobs: None = None) -> Dict:
         """Executes a deployed AI agent function with binary data as inputs.
@@ -7924,17 +7929,18 @@ Creates a new feature group defined as the union of other feature group versions
             list[AbacusApi]: A list of suggested Abacus APIs"""
         return self._call_api('suggestAbacusApis', 'POST', query_params={}, body={'query': query, 'verbosity': verbosity, 'limit': limit, 'includeScores': include_scores}, parse_type=AbacusApi)
 
-    def create_deployment_conversation(self, deployment_id: str, name: str, deployment_token: str = None) -> DeploymentConversation:
+    def create_deployment_conversation(self, deployment_id: str, name: str, deployment_token: str = None, external_application_id: str = None) -> DeploymentConversation:
         """Creates a deployment conversation.
 
         Args:
             deployment_id (str): The deployment this conversation belongs to.
             name (str): The name of the conversation.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in.
+            external_application_id (str): The external application id associated with the deployment conversation.
 
         Returns:
             DeploymentConversation: The deployment conversation."""
-        return self._proxy_request('createDeploymentConversation', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'name': name}, parse_type=DeploymentConversation, is_sync=True)
+        return self._proxy_request('createDeploymentConversation', 'POST', query_params={'deploymentId': deployment_id, 'deploymentToken': deployment_token}, body={'name': name, 'externalApplicationId': external_application_id}, parse_type=DeploymentConversation, is_sync=True)
 
     def delete_deployment_conversation(self, deployment_conversation_id: str, deployment_id: str = None, deployment_token: str = None):
         """Delete a Deployment Conversation.

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/deployment.py

@@ -455,18 +455,19 @@ class Deployment(AbstractApiClass):
         """
         return self.client.get_feature_group_row_process_logs_by_key(self.deployment_id, primary_key_value)
 
-    def create_conversation(self, name: str, deployment_token: str = None):
+    def create_conversation(self, name: str, deployment_token: str = None, external_application_id: str = None):
         """
         Creates a deployment conversation.
 
         Args:
             name (str): The name of the conversation.
             deployment_token (str): The deployment token to authenticate access to the deployment. This is required if not logged in.
+            external_application_id (str): The external application id associated with the deployment conversation.
 
         Returns:
             DeploymentConversation: The deployment conversation.
         """
-        return self.client.create_deployment_conversation(self.deployment_id, name, deployment_token)
+        return self.client.create_deployment_conversation(self.deployment_id, name, deployment_token, external_application_id)
 
     def list_conversations(self):
         """

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/deployment_conversation.py

@@ -15,10 +15,11 @@ class DeploymentConversation(AbstractApiClass):
             lastEventCreatedAt (str): The timestamp at which the most recent corresponding deployment conversation event was created at.
             externalSessionId (str): The external session id associated with the deployment conversation.
             regenerateAttempt (int): The sequence number of regeneration. Not regenerated if 0.
+            externalApplicationId (str): The external application id associated with the deployment conversation.
             history (DeploymentConversationEvent): The history of the deployment conversation.
     """
 
-    def __init__(self, client, deploymentConversationId=None, name=None, deploymentId=None, createdAt=None, lastEventCreatedAt=None, externalSessionId=None, regenerateAttempt=None, history={}):
+    def __init__(self, client, deploymentConversationId=None, name=None, deploymentId=None, createdAt=None, lastEventCreatedAt=None, externalSessionId=None, regenerateAttempt=None, externalApplicationId=None, history={}):
         super().__init__(client, deploymentConversationId)
         self.deployment_conversation_id = deploymentConversationId
         self.name = name
@@ -27,13 +28,14 @@ class DeploymentConversation(AbstractApiClass):
         self.last_event_created_at = lastEventCreatedAt
         self.external_session_id = externalSessionId
         self.regenerate_attempt = regenerateAttempt
+        self.external_application_id = externalApplicationId
         self.history = client._build_class(
             DeploymentConversationEvent, history)
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'deployment_conversation_id': repr(self.deployment_conversation_id), f'name': repr(self.name), f'deployment_id': repr(self.deployment_id), f'created_at': repr(
-            self.created_at), f'last_event_created_at': repr(self.last_event_created_at), f'external_session_id': repr(self.external_session_id), f'regenerate_attempt': repr(self.regenerate_attempt), f'history': repr(self.history)}
+        repr_dict = {f'deployment_conversation_id': repr(self.deployment_conversation_id), f'name': repr(self.name), f'deployment_id': repr(self.deployment_id), f'created_at': repr(self.created_at), f'last_event_created_at': repr(
+            self.last_event_created_at), f'external_session_id': repr(self.external_session_id), f'regenerate_attempt': repr(self.regenerate_attempt), f'external_application_id': repr(self.external_application_id), f'history': repr(self.history)}
         class_name = "DeploymentConversation"
         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])
@@ -46,8 +48,8 @@ class DeploymentConversation(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'deployment_conversation_id': self.deployment_conversation_id, 'name': self.name, 'deployment_id': self.deployment_id, 'created_at': self.created_at, 'last_event_created_at':
-                self.last_event_created_at, 'external_session_id': self.external_session_id, 'regenerate_attempt': self.regenerate_attempt, 'history': self._get_attribute_as_dict(self.history)}
+        resp = {'deployment_conversation_id': self.deployment_conversation_id, 'name': self.name, 'deployment_id': self.deployment_id, 'created_at': self.created_at, 'last_event_created_at': self.last_event_created_at,
+                'external_session_id': self.external_session_id, 'regenerate_attempt': self.regenerate_attempt, 'external_application_id': self.external_application_id, 'history': self._get_attribute_as_dict(self.history)}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}
 
     def get(self, external_session_id: str = None, deployment_id: str = None, deployment_token: str = None, filter_intermediate_conversation_events: bool = True):

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/document_data.py

@@ -17,9 +17,10 @@ class DocumentData(AbstractApiClass):
             tokens (list): List of extracted tokens in the document obtained from OCR.
             metadata (list): List of metadata for each page in the document.
             pageMarkdown (list): The markdown text for the page.
+            extractedPageText (list): List of extracted text for each page in the document obtained from OCR.
     """
 
-    def __init__(self, client, docId=None, mimeType=None, pageCount=None, totalPageCount=None, extractedText=None, embeddedText=None, pages=None, tokens=None, metadata=None, pageMarkdown=None):
+    def __init__(self, client, docId=None, mimeType=None, pageCount=None, totalPageCount=None, extractedText=None, embeddedText=None, pages=None, tokens=None, metadata=None, pageMarkdown=None, extractedPageText=None):
         super().__init__(client, None)
         self.doc_id = docId
         self.mime_type = mimeType
@@ -31,11 +32,12 @@ class DocumentData(AbstractApiClass):
         self.tokens = tokens
         self.metadata = metadata
         self.page_markdown = pageMarkdown
+        self.extracted_page_text = extractedPageText
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'doc_id': repr(self.doc_id), f'mime_type': repr(self.mime_type), f'page_count': repr(self.page_count), f'total_page_count': repr(self.total_page_count), f'extracted_text': repr(
-            self.extracted_text), f'embedded_text': repr(self.embedded_text), f'pages': repr(self.pages), f'tokens': repr(self.tokens), f'metadata': repr(self.metadata), f'page_markdown': repr(self.page_markdown)}
+        repr_dict = {f'doc_id': repr(self.doc_id), f'mime_type': repr(self.mime_type), f'page_count': repr(self.page_count), f'total_page_count': repr(self.total_page_count), f'extracted_text': repr(self.extracted_text), f'embedded_text': repr(
+            self.embedded_text), f'pages': repr(self.pages), f'tokens': repr(self.tokens), f'metadata': repr(self.metadata), f'page_markdown': repr(self.page_markdown), f'extracted_page_text': repr(self.extracted_page_text)}
         class_name = "DocumentData"
         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])
@@ -49,5 +51,5 @@ class DocumentData(AbstractApiClass):
             dict: The dict value representation of the class parameters
         """
         resp = {'doc_id': self.doc_id, 'mime_type': self.mime_type, 'page_count': self.page_count, 'total_page_count': self.total_page_count, 'extracted_text': self.extracted_text,
-                'embedded_text': self.embedded_text, 'pages': self.pages, 'tokens': self.tokens, 'metadata': self.metadata, 'page_markdown': self.page_markdown}
+                'embedded_text': self.embedded_text, 'pages': self.pages, 'tokens': self.tokens, 'metadata': self.metadata, 'page_markdown': self.page_markdown, 'extracted_page_text': self.extracted_page_text}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/document_retriever.py

@@ -1,4 +1,4 @@
-from typing import Union
+from typing import Dict, Union
 
 from .api_class import DocumentRetrieverConfig
 from .document_retriever_config import DocumentRetrieverConfig
@@ -209,7 +209,7 @@ class DocumentRetriever(AbstractApiClass):
         """
         return self.describe().latest_document_retriever_version.deployment_status
 
-    def get_matching_documents(self, query: str, filters: dict = None, limit: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None, max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None, filter_clause: str = None):
+    def get_matching_documents(self, query: str, filters: dict = None, limit: int = None, result_columns: list = None, max_words: int = None, num_retrieval_margin_words: int = None, max_words_per_chunk: int = None, score_multiplier_column: str = None, min_score: float = None, required_phrases: list = None, filter_clause: str = None, crowding_limits: Dict[str, int] = None):
         """
         Lookup document retrievers and return the matching documents from the document retriever deployed with given query.
 
@@ -230,8 +230,9 @@ class DocumentRetriever(AbstractApiClass):
             min_score (float): If provided, will filter out the results with score lower than the value specified.
             required_phrases (list): If provided, each result will have at least one of the phrases.
             filter_clause (str): If provided, filter the results of the query using this sql where clause.
+            crowding_limits (dict): A dictionary mapping metadata columns to the maximum number of results per unique value of the column. This is used to ensure diversity of metadata attribute values in the results. If a particular attribute value has already reached its maximum count, further results with that same attribute value will be excluded from the final result set.
 
         Returns:
             list[DocumentRetrieverLookupResult]: The relevant documentation results found from the document retriever.
         """
-        return self.client.get_matching_documents(self.document_retriever_id, query, filters, limit, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause)
+        return self.client.get_matching_documents(self.document_retriever_id, query, filters, limit, result_columns, max_words, num_retrieval_margin_words, max_words_per_chunk, score_multiplier_column, min_score, required_phrases, filter_clause, crowding_limits)

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/external_application.py

@@ -18,9 +18,10 @@ class ExternalApplication(AbstractApiClass):
             status (str): The status of the deployment.
             deploymentConversationRetentionHours (int): The retention policy for the external application.
             managedUserService (str): The external service that is managing the user accounts.
+            predictionOverrides (dict): The prediction overrides for the external application.
     """
 
-    def __init__(self, client, name=None, externalApplicationId=None, deploymentId=None, description=None, logo=None, theme=None, userGroupIds=None, useCase=None, status=None, deploymentConversationRetentionHours=None, managedUserService=None):
+    def __init__(self, client, name=None, externalApplicationId=None, deploymentId=None, description=None, logo=None, theme=None, userGroupIds=None, useCase=None, status=None, deploymentConversationRetentionHours=None, managedUserService=None, predictionOverrides=None):
         super().__init__(client, externalApplicationId)
         self.name = name
         self.external_application_id = externalApplicationId
@@ -33,11 +34,12 @@ class ExternalApplication(AbstractApiClass):
         self.status = status
         self.deployment_conversation_retention_hours = deploymentConversationRetentionHours
         self.managed_user_service = managedUserService
+        self.prediction_overrides = predictionOverrides
         self.deprecated_keys = {}
 
     def __repr__(self):
         repr_dict = {f'name': repr(self.name), f'external_application_id': repr(self.external_application_id), f'deployment_id': repr(self.deployment_id), f'description': repr(self.description), f'logo': repr(self.logo), f'theme': repr(self.theme), f'user_group_ids': repr(
-            self.user_group_ids), f'use_case': repr(self.use_case), f'status': repr(self.status), f'deployment_conversation_retention_hours': repr(self.deployment_conversation_retention_hours), f'managed_user_service': repr(self.managed_user_service)}
+            self.user_group_ids), f'use_case': repr(self.use_case), f'status': repr(self.status), f'deployment_conversation_retention_hours': repr(self.deployment_conversation_retention_hours), f'managed_user_service': repr(self.managed_user_service), f'prediction_overrides': repr(self.prediction_overrides)}
         class_name = "ExternalApplication"
         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])
@@ -50,8 +52,8 @@ class ExternalApplication(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'name': self.name, 'external_application_id': self.external_application_id, 'deployment_id': self.deployment_id, 'description': self.description, 'logo': self.logo, 'theme': self.theme,
-                'user_group_ids': self.user_group_ids, 'use_case': self.use_case, 'status': self.status, 'deployment_conversation_retention_hours': self.deployment_conversation_retention_hours, 'managed_user_service': self.managed_user_service}
+        resp = {'name': self.name, 'external_application_id': self.external_application_id, 'deployment_id': self.deployment_id, 'description': self.description, 'logo': self.logo, 'theme': self.theme, 'user_group_ids': self.user_group_ids,
+                'use_case': self.use_case, 'status': self.status, 'deployment_conversation_retention_hours': self.deployment_conversation_retention_hours, 'managed_user_service': self.managed_user_service, 'prediction_overrides': self.prediction_overrides}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}
 
     def update(self, name: str = None, description: str = None, theme: dict = None, deployment_id: str = None, deployment_conversation_retention_hours: int = None, reset_retention_policy: bool = False):

{abacusai-1.2.5 → abacusai-1.2.7}/abacusai/feature_group.py

@@ -2,7 +2,7 @@ import io
 from typing import List, Union
 
 from .annotation_config import AnnotationConfig
-from .api_class import MergeConfig, SamplingConfig
+from .api_class import MergeConfig, ProjectFeatureGroupConfig, SamplingConfig
 from .code_source import CodeSource
 from .concatenation_config import ConcatenationConfig
 from .feature import Feature
@@ -157,13 +157,13 @@ class FeatureGroup(AbstractApiClass):
         """
         return self.client.add_feature_group_to_project(self.feature_group_id, project_id, feature_group_type)
 
-    def set_project_config(self, project_id: str, project_config: dict = None):
+    def set_project_config(self, project_id: str, project_config: Union[dict, ProjectFeatureGroupConfig] = None):
         """
         Sets a feature group's project config
 
         Args:
             project_id (str): Unique string identifier for the project.
-            project_config (dict): JSON object for the feature group's project configuration.
+            project_config (ProjectFeatureGroupConfig): Feature group's project configuration.
         """
         return self.client.set_project_feature_group_config(self.feature_group_id, project_id, project_config)