abacusai 1.4.5__tar.gz → 1.4.79__tar.gz

{abacusai-1.4.5/abacusai.egg-info → abacusai-1.4.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: abacusai
-Version: 1.4.5
+Version: 1.4.79
 Summary: Abacus.AI Python Client Library
 Home-page: https://github.com/abacusai/api-python
 Author: Abacus.AI
@@ -9,7 +9,6 @@ License: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Utilities
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -17,8 +16,3 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 License-File: LICENSE
-Requires-Dist: packaging
-Requires-Dist: requests
-Requires-Dist: pandas
-Requires-Dist: fastavro
-Requires-Dist: typing_inspect; python_version < "3.8"

{abacusai-1.4.5 → abacusai-1.4.79}/README.md

@@ -9,12 +9,6 @@ The official Python API Client Library for Abacus.AI.
 $ pip install abacusai
 ```
 
-## Documentation
-
-Function Documentation: https://abacusai.github.io/api-python/autoapi/abacusai/index.html
-
-For a full list of APIs and code snippet examples, see the [Abacus.AI Documentation](https://abacus.ai/app/help/ref/overview).
-
 ## Getting Started
 
 ### Calling an API
@@ -26,5 +20,13 @@ from abacusai import ApiClient
 client = ApiClient('YOUR_API_KEY')
 ```
 
+You can find your API key from here: [API KEY](https://abacus.ai/app/profile/apikey)
+
+## Documentation
+
+- Python SDK Documentation: [Abacus.AI Python SDK](https://abacusai.github.io/api-python/autoapi/abacusai/index.html)
+- Full list of API's and examples: [Abacus.AI APIs Reference](https://abacus.ai/app/help/ref/overview)
+- Python usage examples: [Examples Repository](https://github.com/abacusai/api-python/blob/main/examples)
+
 ## License
 [MIT](https://github.com/abacusai/api-python/blob/main/LICENSE)

abacusai-1.4.79/abacusai/__init__.py

@@ -0,0 +1,299 @@
+from .abacus_api import AbacusApi
+from .address import Address
+from .agent import Agent
+from .agent_chat_message import AgentChatMessage
+from .agent_conversation import AgentConversation
+from .agent_data_document_info import AgentDataDocumentInfo
+from .agent_data_execution_result import AgentDataExecutionResult
+from .agent_version import AgentVersion
+from .ai_building_task import AiBuildingTask
+from .algorithm import Algorithm
+from .annotation import Annotation
+from .annotation_config import AnnotationConfig
+from .annotation_document import AnnotationDocument
+from .annotation_entry import AnnotationEntry
+from .annotations_status import AnnotationsStatus
+from .api_class import *
+from .api_endpoint import ApiEndpoint
+from .api_key import ApiKey
+from .app_user_group import AppUserGroup
+from .app_user_group_sign_in_token import AppUserGroupSignInToken
+from .application_connector import ApplicationConnector
+from .audio_gen_settings import AudioGenSettings
+from .audio_url_result import AudioUrlResult
+from .audit_log import AuditLog
+from .batch_prediction import BatchPrediction
+from .batch_prediction_version import BatchPredictionVersion
+from .batch_prediction_version_logs import BatchPredictionVersionLogs
+from .bot_info import BotInfo
+from .categorical_range_violation import CategoricalRangeViolation
+from .chat_message import ChatMessage
+from .chat_session import ChatSession
+from .chatllm_computer import ChatllmComputer
+from .chatllm_computer_status import ChatllmComputerStatus
+from .chatllm_memory import ChatllmMemory
+from .chatllm_project import ChatllmProject
+from .chatllm_project_permissions import ChatllmProjectPermissions
+from .chatllm_referral_invite import ChatllmReferralInvite
+from .chatllm_task import ChatllmTask
+from .client import AgentResponse, ApiClient, ApiException, ClientOptions, ReadOnlyClient, ToolResponse, _request_context
+from .code_agent_response import CodeAgentResponse
+from .code_autocomplete_edit_prediction_response import CodeAutocompleteEditPredictionResponse
+from .code_autocomplete_response import CodeAutocompleteResponse
+from .code_bot import CodeBot
+from .code_edit import CodeEdit
+from .code_edit_response import CodeEditResponse
+from .code_edits import CodeEdits
+from .code_embeddings import CodeEmbeddings
+from .code_llm_changed_files import CodeLlmChangedFiles
+from .code_source import CodeSource
+from .code_suggestion_validation_response import CodeSuggestionValidationResponse
+from .code_summary_response import CodeSummaryResponse
+from .codellm_embedding_constants import CodellmEmbeddingConstants
+from .compute_point_info import ComputePointInfo
+from .concatenation_config import ConcatenationConfig
+from .constants_autocomplete_response import ConstantsAutocompleteResponse
+from .cpu_gpu_memory_specs import CpuGpuMemorySpecs
+from .custom_chat_instructions import CustomChatInstructions
+from .custom_domain import CustomDomain
+from .custom_loss_function import CustomLossFunction
+from .custom_metric import CustomMetric
+from .custom_metric_version import CustomMetricVersion
+from .custom_train_function_info import CustomTrainFunctionInfo
+from .daemon_task_conversation import DaemonTaskConversation
+from .data_consistency_duplication import DataConsistencyDuplication
+from .data_metrics import DataMetrics
+from .data_prep_logs import DataPrepLogs
+from .data_quality_results import DataQualityResults
+from .data_upload_result import DataUploadResult
+from .database_column_feature_mapping import DatabaseColumnFeatureMapping
+from .database_connector import DatabaseConnector
+from .database_connector_column import DatabaseConnectorColumn
+from .database_connector_schema import DatabaseConnectorSchema
+from .dataset import Dataset
+from .dataset_column import DatasetColumn
+from .dataset_version import DatasetVersion
+from .dataset_version_logs import DatasetVersionLogs
+from .default_llm import DefaultLlm
+from .deployment import Deployment
+from .deployment_auth_token import DeploymentAuthToken
+from .deployment_conversation import DeploymentConversation
+from .deployment_conversation_event import DeploymentConversationEvent
+from .deployment_conversation_export import DeploymentConversationExport
+from .deployment_statistics import DeploymentStatistics
+from .document_data import DocumentData
+from .document_retriever import DocumentRetriever
+from .document_retriever_lookup_result import DocumentRetrieverLookupResult
+from .document_retriever_version import DocumentRetrieverVersion
+from .document_retriever_version_logs import DocumentRetrieverVersionLogs
+from .domain_purchase_result import DomainPurchaseResult
+from .domain_search_result import DomainSearchResult
+from .drift_distribution import DriftDistribution
+from .drift_distributions import DriftDistributions
+from .eda import Eda
+from .eda_chart_description import EdaChartDescription
+from .eda_collinearity import EdaCollinearity
+from .eda_data_consistency import EdaDataConsistency
+from .eda_feature_association import EdaFeatureAssociation
+from .eda_feature_collinearity import EdaFeatureCollinearity
+from .eda_forecasting_analysis import EdaForecastingAnalysis
+from .eda_version import EdaVersion
+from .edit_image_models import EditImageModels
+from .embedding_feature_drift_distribution import EmbeddingFeatureDriftDistribution
+from .entri_auth_token import EntriAuthToken
+from .execute_feature_group_operation import ExecuteFeatureGroupOperation
+from .external_application import ExternalApplication
+from .external_invite import ExternalInvite
+from .extracted_fields import ExtractedFields
+from .feature import Feature
+from .feature_distribution import FeatureDistribution
+from .feature_drift_record import FeatureDriftRecord
+from .feature_drift_summary import FeatureDriftSummary
+from .feature_group import FeatureGroup
+from .feature_group_document import FeatureGroupDocument
+from .feature_group_export import FeatureGroupExport
+from .feature_group_export_config import FeatureGroupExportConfig
+from .feature_group_export_download_url import FeatureGroupExportDownloadUrl
+from .feature_group_lineage import FeatureGroupLineage
+from .feature_group_refresh_export_config import FeatureGroupRefreshExportConfig
+from .feature_group_row import FeatureGroupRow
+from .feature_group_row_process import FeatureGroupRowProcess
+from .feature_group_row_process_logs import FeatureGroupRowProcessLogs
+from .feature_group_row_process_summary import FeatureGroupRowProcessSummary
+from .feature_group_template import FeatureGroupTemplate
+from .feature_group_template_variable_options import FeatureGroupTemplateVariableOptions
+from .feature_group_version import FeatureGroupVersion
+from .feature_group_version_logs import FeatureGroupVersionLogs
+from .feature_importance import FeatureImportance
+from .feature_mapping import FeatureMapping
+from .feature_performance_analysis import FeaturePerformanceAnalysis
+from .file_connector import FileConnector
+from .file_connector_instructions import FileConnectorInstructions
+from .file_connector_verification import FileConnectorVerification
+from .finetuned_pretrained_model import FinetunedPretrainedModel
+from .forecasting_analysis_graph_data import ForecastingAnalysisGraphData
+from .forecasting_monitor_item_analysis import ForecastingMonitorItemAnalysis
+from .forecasting_monitor_summary import ForecastingMonitorSummary
+from .fs_entry import FsEntry
+from .function_logs import FunctionLogs
+from .generated_pit_feature_config_option import GeneratedPitFeatureConfigOption
+from .graph_dashboard import GraphDashboard
+from .holdout_analysis import HoldoutAnalysis
+from .holdout_analysis_version import HoldoutAnalysisVersion
+from .hosted_app import HostedApp
+from .hosted_app_container import HostedAppContainer
+from .hosted_app_file_read import HostedAppFileRead
+from .hosted_artifact import HostedArtifact
+from .hosted_database import HostedDatabase
+from .hosted_database_snapshot import HostedDatabaseSnapshot
+from .hosted_model_token import HostedModelToken
+from .hostname_info import HostnameInfo
+from .hume_voice import HumeVoice
+from .image_gen_model import ImageGenModel
+from .image_gen_model_options import ImageGenModelOptions
+from .image_gen_settings import ImageGenSettings
+from .indexing_config import IndexingConfig
+from .inferred_database_column_to_feature_mappings import InferredDatabaseColumnToFeatureMappings
+from .inferred_feature_mappings import InferredFeatureMappings
+from .item_statistics import ItemStatistics
+from .lip_sync_gen_settings import LipSyncGenSettings
+from .llm_app import LlmApp
+from .llm_artifact import LlmArtifact
+from .llm_code_block import LlmCodeBlock
+from .llm_execution_preview import LlmExecutionPreview
+from .llm_execution_result import LlmExecutionResult
+from .llm_generated_code import LlmGeneratedCode
+from .llm_input import LlmInput
+from .llm_parameters import LlmParameters
+from .llm_response import LlmResponse
+from .mcp_config import McpConfig
+from .mcp_server import McpServer
+from .mcp_server_connection import McpServerConnection
+from .mcp_server_query_result import McpServerQueryResult
+from .memory_options import MemoryOptions
+from .messaging_connector_response import MessagingConnectorResponse
+from .mobile_app_build_status import MobileAppBuildStatus
+from .model import Model
+from .model_artifacts_export import ModelArtifactsExport
+from .model_blueprint_export import ModelBlueprintExport
+from .model_blueprint_stage import ModelBlueprintStage
+from .model_location import ModelLocation
+from .model_metrics import ModelMetrics
+from .model_monitor import ModelMonitor
+from .model_monitor_org_summary import ModelMonitorOrgSummary
+from .model_monitor_summary import ModelMonitorSummary
+from .model_monitor_summary_from_org import ModelMonitorSummaryFromOrg
+from .model_monitor_version import ModelMonitorVersion
+from .model_monitor_version_metric_data import ModelMonitorVersionMetricData
+from .model_training_type_for_deployment import ModelTrainingTypeForDeployment
+from .model_upload import ModelUpload
+from .model_version import ModelVersion
+from .model_version_feature_group_schema import ModelVersionFeatureGroupSchema
+from .modification_lock_info import ModificationLockInfo
+from .module import Module
+from .monitor_alert import MonitorAlert
+from .monitor_alert_version import MonitorAlertVersion
+from .monitor_drift_and_distributions import MonitorDriftAndDistributions
+from .natural_language_explanation import NaturalLanguageExplanation
+from .nested_feature import NestedFeature
+from .nested_feature_schema import NestedFeatureSchema
+from .news_search_result import NewsSearchResult
+from .nlp_chat_response import NlpChatResponse
+from .notebook_completion import NotebookCompletion
+from .notebook_template import NotebookTemplate
+from .null_violation import NullViolation
+from .organization_external_application_settings import OrganizationExternalApplicationSettings
+from .organization_group import OrganizationGroup
+from .organization_search_result import OrganizationSearchResult
+from .organization_secret import OrganizationSecret
+from .page_data import PageData
+from .pipeline import Pipeline
+from .pipeline_reference import PipelineReference
+from .pipeline_step import PipelineStep
+from .pipeline_step_version import PipelineStepVersion
+from .pipeline_step_version_logs import PipelineStepVersionLogs
+from .pipeline_step_version_reference import PipelineStepVersionReference
+from .pipeline_version import PipelineVersion
+from .pipeline_version_logs import PipelineVersionLogs
+from .playground_text import PlaygroundText
+from .point_in_time_feature import PointInTimeFeature
+from .point_in_time_feature_info import PointInTimeFeatureInfo
+from .point_in_time_group import PointInTimeGroup
+from .point_in_time_group_feature import PointInTimeGroupFeature
+from .prediction_client import PredictionClient
+from .prediction_dataset import PredictionDataset
+from .prediction_feature_group import PredictionFeatureGroup
+from .prediction_input import PredictionInput
+from .prediction_log_record import PredictionLogRecord
+from .prediction_operator import PredictionOperator
+from .prediction_operator_version import PredictionOperatorVersion
+from .presentation_export_result import PresentationExportResult
+from .private_web_app_deployment import PrivateWebAppDeployment
+from .problem_type import ProblemType
+from .project import Project
+from .project_config import ProjectConfig
+from .project_feature_group import ProjectFeatureGroup
+from .project_feature_group_schema import ProjectFeatureGroupSchema
+from .project_feature_group_schema_version import ProjectFeatureGroupSchemaVersion
+from .project_validation import ProjectValidation
+from .python_function import PythonFunction
+from .python_plot_function import PythonPlotFunction
+from .range_violation import RangeViolation
+from .razorpay_payment_requirements import RazorpayPaymentRequirements
+from .razorpay_payment_status import RazorpayPaymentStatus
+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 .regenerate_llm_option import RegenerateLlmOption
+from .resolved_feature_group_template import ResolvedFeatureGroupTemplate
+from .routing_action import RoutingAction
+from .schema import Schema
+from .session_summary import SessionSummary
+from .session_transcript import SessionTranscript
+from .session_transcripts import SessionTranscripts
+from .sftp_key import SftpKey
+from .streaming_auth_token import StreamingAuthToken
+from .streaming_client import StreamingClient
+from .streaming_connector import StreamingConnector
+from .streaming_row_count import StreamingRowCount
+from .streaming_sample_code import StreamingSampleCode
+from .sts_gen_settings import StsGenSettings
+from .stt_gen_model import SttGenModel
+from .stt_gen_model_options import SttGenModelOptions
+from .stt_gen_settings import SttGenSettings
+from .template_node_details import TemplateNodeDetails
+from .test_point_predictions import TestPointPredictions
+from .tone_details import ToneDetails
+from .training_config_options import TrainingConfigOptions
+from .tts_gen_settings import TtsGenSettings
+from .twitter_search_result import TwitterSearchResult
+from .unified_connector import UnifiedConnector
+from .upload import Upload
+from .upload_part import UploadPart
+from .use_case import UseCase
+from .use_case_requirements import UseCaseRequirements
+from .user import User
+from .user_exception import UserException
+from .user_group_object_permission import UserGroupObjectPermission
+from .video_gen_costs import VideoGenCosts
+from .video_gen_model import VideoGenModel
+from .video_gen_model_options import VideoGenModelOptions
+from .video_gen_settings import VideoGenSettings
+from .video_search_result import VideoSearchResult
+from .voice_gen_details import VoiceGenDetails
+from .web_app_conversation import WebAppConversation
+from .web_app_deployment import WebAppDeployment
+from .web_app_deployment_permission_dict import WebAppDeploymentPermissionDict
+from .web_app_domain import WebAppDomain
+from .web_page_response import WebPageResponse
+from .web_search_response import WebSearchResponse
+from .web_search_result import WebSearchResult
+from .web_service_trigger_run import WebServiceTriggerRun
+from .webhook import Webhook
+from .workflow_graph_node_details import WorkflowGraphNodeDetails
+from .workflow_node_template import WorkflowNodeTemplate
+
+
+__version__ = "1.4.79"

abacusai-1.4.79/abacusai/address.py

@@ -0,0 +1,49 @@
+from .return_class import AbstractApiClass
+
+
+class Address(AbstractApiClass):
+    """
+        Address object
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            addressLine1 (str): The first line of the address
+            addressLine2 (str): The second line of the address
+            city (str): The city
+            stateOrProvince (str): The state or province
+            postalCode (str): The postal code
+            country (str): The country
+            additionalInfo (str): Additional information for invoice
+            includeReverseCharge (bool): Whether the organization needs the reverse charge mechanism applied to invoices.
+    """
+
+    def __init__(self, client, addressLine1=None, addressLine2=None, city=None, stateOrProvince=None, postalCode=None, country=None, additionalInfo=None, includeReverseCharge=None):
+        super().__init__(client, None)
+        self.address_line_1 = addressLine1
+        self.address_line_2 = addressLine2
+        self.city = city
+        self.state_or_province = stateOrProvince
+        self.postal_code = postalCode
+        self.country = country
+        self.additional_info = additionalInfo
+        self.include_reverse_charge = includeReverseCharge
+        self.deprecated_keys = {}
+
+    def __repr__(self):
+        repr_dict = {f'address_line_1': repr(self.address_line_1), f'address_line_2': repr(self.address_line_2), f'city': repr(self.city), f'state_or_province': repr(self.state_or_province), f'postal_code': repr(
+            self.postal_code), f'country': repr(self.country), f'additional_info': repr(self.additional_info), f'include_reverse_charge': repr(self.include_reverse_charge)}
+        class_name = "Address"
+        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 = {'address_line_1': self.address_line_1, 'address_line_2': self.address_line_2, 'city': self.city, 'state_or_province': self.state_or_province,
+                'postal_code': self.postal_code, 'country': self.country, 'additional_info': self.additional_info, 'include_reverse_charge': self.include_reverse_charge}
+        return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}

{abacusai-1.4.5 → abacusai-1.4.79}/abacusai/agent.py

@@ -23,10 +23,11 @@ class Agent(AbstractApiClass):
             agentExecutionConfig (dict): The config for arguments used to execute the agent.
             latestAgentVersion (AgentVersion): The latest agent version.
             codeSource (CodeSource): If a python model, information on the source code
+            draftWorkflowGraph (WorkflowGraph): The saved draft state of the workflow graph for the agent.
             workflowGraph (WorkflowGraph): The workflow graph for the agent.
     """
 
-    def __init__(self, client, name=None, agentId=None, createdAt=None, projectId=None, notebookId=None, predictFunctionName=None, sourceCode=None, agentConfig=None, memory=None, trainingRequired=None, agentExecutionConfig=None, codeSource={}, latestAgentVersion={}, workflowGraph={}):
+    def __init__(self, client, name=None, agentId=None, createdAt=None, projectId=None, notebookId=None, predictFunctionName=None, sourceCode=None, agentConfig=None, memory=None, trainingRequired=None, agentExecutionConfig=None, codeSource={}, latestAgentVersion={}, draftWorkflowGraph={}, workflowGraph={}):
         super().__init__(client, agentId)
         self.name = name
         self.agent_id = agentId
@@ -42,12 +43,14 @@ class Agent(AbstractApiClass):
         self.code_source = client._build_class(CodeSource, codeSource)
         self.latest_agent_version = client._build_class(
             AgentVersion, latestAgentVersion)
+        self.draft_workflow_graph = client._build_class(
+            WorkflowGraph, draftWorkflowGraph)
         self.workflow_graph = client._build_class(WorkflowGraph, workflowGraph)
         self.deprecated_keys = {}
 
     def __repr__(self):
-        repr_dict = {f'name': repr(self.name), f'agent_id': repr(self.agent_id), f'created_at': repr(self.created_at), f'project_id': repr(self.project_id), f'notebook_id': repr(self.notebook_id), f'predict_function_name': repr(self.predict_function_name), f'source_code': repr(self.source_code), f'agent_config': repr(
-            self.agent_config), f'memory': repr(self.memory), f'training_required': repr(self.training_required), f'agent_execution_config': repr(self.agent_execution_config), f'code_source': repr(self.code_source), f'latest_agent_version': repr(self.latest_agent_version), f'workflow_graph': repr(self.workflow_graph)}
+        repr_dict = {f'name': repr(self.name), f'agent_id': repr(self.agent_id), f'created_at': repr(self.created_at), f'project_id': repr(self.project_id), f'notebook_id': repr(self.notebook_id), f'predict_function_name': repr(self.predict_function_name), f'source_code': repr(self.source_code), f'agent_config': repr(self.agent_config), f'memory': repr(
+            self.memory), f'training_required': repr(self.training_required), f'agent_execution_config': repr(self.agent_execution_config), f'code_source': repr(self.code_source), f'latest_agent_version': repr(self.latest_agent_version), f'draft_workflow_graph': repr(self.draft_workflow_graph), f'workflow_graph': repr(self.workflow_graph)}
         class_name = "Agent"
         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])
@@ -60,8 +63,8 @@ class Agent(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        resp = {'name': self.name, 'agent_id': self.agent_id, 'created_at': self.created_at, 'project_id': self.project_id, 'notebook_id': self.notebook_id, 'predict_function_name': self.predict_function_name, 'source_code': self.source_code, 'agent_config': self.agent_config, 'memory': self.memory,
-                'training_required': self.training_required, 'agent_execution_config': self.agent_execution_config, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version), 'workflow_graph': self._get_attribute_as_dict(self.workflow_graph)}
+        resp = {'name': self.name, 'agent_id': self.agent_id, 'created_at': self.created_at, 'project_id': self.project_id, 'notebook_id': self.notebook_id, 'predict_function_name': self.predict_function_name, 'source_code': self.source_code, 'agent_config': self.agent_config, 'memory': self.memory, 'training_required': self.training_required,
+                'agent_execution_config': self.agent_execution_config, 'code_source': self._get_attribute_as_dict(self.code_source), 'latest_agent_version': self._get_attribute_as_dict(self.latest_agent_version), 'draft_workflow_graph': self._get_attribute_as_dict(self.draft_workflow_graph), 'workflow_graph': self._get_attribute_as_dict(self.workflow_graph)}
         return {key: value for key, value in resp.items() if value is not None and key not in self.deprecated_keys}
 
     def refresh(self):
@@ -99,6 +102,39 @@ class Agent(AbstractApiClass):
         """
         return self.client.list_agent_versions(self.agent_id, limit, start_after_version)
 
+    def copy(self, project_id: str = None):
+        """
+        Creates a copy of the input agent
+
+        Args:
+            project_id (str): Project id to create the new agent to. By default it picks up the source agent's project id.
+
+        Returns:
+            Agent: The newly generated agent.
+        """
+        return self.client.copy_agent(self.agent_id, project_id)
+
+    @property
+    def description(self) -> str:
+        """
+        The description of the agent.
+        """
+        return (self.agent_config or {}).get('DESCRIPTION')
+
+    @property
+    def agent_interface(self) -> str:
+        """
+        The interface that the agent will be deployed with.
+        """
+        return (self.agent_config or {}).get('AGENT_INTERFACE')
+
+    @property
+    def agent_connectors(self) -> 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.
+        """
+        return (self.agent_config or {}).get('AGENT_CONNECTORS')
+
     def wait_for_publish(self, timeout=None):
         """
         A waiting call until agent is published.

abacusai-1.4.79/abacusai/agent_chat_message.py

@@ -0,0 +1,49 @@
+from .return_class import AbstractApiClass
+
+
+class AgentChatMessage(AbstractApiClass):
+    """
+        A single chat message with Agent Chat.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            role (str): The role of the message sender
+            text (list[dict]): A list of text segments for the message
+            docIds (list[str]): A list of IDs of the uploaded document if the message has
+            keywordArguments (dict): User message only. A dictionary of keyword arguments used to generate response.
+            segments (list[dict]): A list of segments for the message
+            streamedData (str): The streamed data for the message
+            streamedSectionData (list): A list of streamed section data for the message
+            agentWorkflowNodeId (str): The workflow node name associated with the agent response.
+    """
+
+    def __init__(self, client, role=None, text=None, docIds=None, keywordArguments=None, segments=None, streamedData=None, streamedSectionData=None, agentWorkflowNodeId=None):
+        super().__init__(client, None)
+        self.role = role
+        self.text = text
+        self.doc_ids = docIds
+        self.keyword_arguments = keywordArguments
+        self.segments = segments
+        self.streamed_data = streamedData
+        self.streamed_section_data = streamedSectionData
+        self.agent_workflow_node_id = agentWorkflowNodeId
+        self.deprecated_keys = {}
+
+    def __repr__(self):
+        repr_dict = {f'role': repr(self.role), f'text': repr(self.text), f'doc_ids': repr(self.doc_ids), f'keyword_arguments': repr(self.keyword_arguments), f'segments': repr(
+            self.segments), f'streamed_data': repr(self.streamed_data), f'streamed_section_data': repr(self.streamed_section_data), f'agent_workflow_node_id': repr(self.agent_workflow_node_id)}
+        class_name = "AgentChatMessage"
+        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 = {'role': self.role, 'text': self.text, 'doc_ids': self.doc_ids, 'keyword_arguments': self.keyword_arguments, 'segments': self.segments,
+                'streamed_data': self.streamed_data, 'streamed_section_data': self.streamed_section_data, 'agent_workflow_node_id': self.agent_workflow_node_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.5 → abacusai-1.4.79}/abacusai/api_class/abstract.py

@@ -7,7 +7,7 @@ import sys
 from abc import ABC
 from copy import deepcopy
 from textwrap import dedent
-from typing import Any, Callable, get_type_hints
+from typing import Any, Callable, Union, _GenericAlias, get_type_hints
 
 
 if sys.version_info >= (3, 8):
@@ -22,6 +22,85 @@ FIRST_CAP_RE = re.compile('(.)([A-Z][a-z]+)')
 ALL_CAP_RE = re.compile('([a-z0-9])([A-Z])')
 
 
+def _validate_instance(value, expected_type):
+    if expected_type == callable:
+        return callable(value)
+    if expected_type is Any:
+        return True
+    elif isinstance(expected_type, _GenericAlias):
+        if expected_type.__origin__ == list:
+            if not isinstance(value, list):
+                return False
+            else:
+                for item in value:
+                    if not _validate_instance(item, expected_type.__args__[0]):
+                        return False
+        elif expected_type.__origin__ == Union:
+            type_match_found = False
+            for possible_type in expected_type.__args__:
+                if _validate_instance(value, possible_type):
+                    type_match_found = True
+                    break
+            return type_match_found
+        elif expected_type.__origin__ == dict:
+            if not isinstance(value, dict):
+                return False
+            else:
+                key_type = expected_type.__args__[0]
+                val_type = expected_type.__args__[1]
+                for key, val in value.items():
+                    if not _validate_instance(key, key_type) or not _validate_instance(val, val_type):
+                        return False
+    else:
+        return isinstance(value, expected_type)
+    return True
+
+
+def _get_user_friendly_type_name(typename):
+    type_value = ''
+    if isinstance(typename, _GenericAlias):
+        if typename.__origin__ == list:
+            type_value = f'a list of {_get_user_friendly_type_name(typename.__args__[0])}'
+        elif typename.__origin__ == dict:
+            type_value += f'a dictionary of key type: {{{_get_user_friendly_type_name(typename.__args__[0])}, {_get_user_friendly_type_name(typename.__args__[1])}}}'
+        elif typename.__origin__ == Union:
+            type_value += f'one of the following types - ( {", ".join([_get_user_friendly_type_name(possible_type) for possible_type in typename.__args__])} )'
+    else:
+        type_value = typename.__name__
+    return type_value
+
+
+def validate_class_method_annotations(classname=None, friendly_class_name=None):
+    if friendly_class_name is None:
+        friendly_class_name = classname
+
+    def validate_types(func):
+        nonlocal classname
+        if classname is None:
+            classname = func.__qualname__.split('.')[0]
+
+        def new_func(*args, **kwargs):
+            sig = inspect.signature(func)
+            bound_args = sig.bind(*args, **kwargs).arguments
+            for keyword, value in list(bound_args.items())[1:]:  # To skip self or cls argument.
+                default_value = sig.parameters[keyword].default
+                if default_value != sig.parameters[keyword].empty and value == default_value:
+                    continue
+                expected_type = func.__annotations__.get(keyword)
+                if not _validate_instance(value, expected_type):
+                    raise ValueError(friendly_class_name, f'Invalid {classname} instance. Argument "{keyword}" must be {_get_user_friendly_type_name(expected_type)}.')
+            func(*args, **kwargs)
+        return new_func
+    return validate_types
+
+
+def validate_constructor_arg_types(friendly_class_name=None):
+    def validate_types(cls):
+        cls.__init__ = validate_class_method_annotations(cls.__name__, friendly_class_name)(cls.__init__)
+        return cls
+    return validate_types
+
+
 def camel_case(value):
     if value:
         components = value.split('_')