abacusai 0.62.1__tar.gz → 0.63.1__tar.gz

{abacusai-0.62.1/abacusai.egg-info → abacusai-0.63.1}/PKG-INFO

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

{abacusai-0.62.1 → abacusai-0.63.1}/abacusai/__init__.py

@@ -4,4 +4,4 @@ from .prediction_client import PredictionClient
 from .streaming_client import StreamingClient
 
 
-__version__ = "0.61.0"
+__version__ = "0.63.0"

{abacusai-0.62.1 → abacusai-0.63.1}/abacusai/annotation.py

@@ -10,16 +10,18 @@ class Annotation(AbstractApiClass):
             annotationType (str): A name determining the type of annotation and how to interpret the annotation value data, e.g. as a label, bounding box, etc.
             annotationValue (dict): JSON-compatible value of the annotation. The format of the value is determined by the annotation type.
             comments (str): Comments about the annotation.
+            metadata (dict): Metadata about the annotation.
     """
 
-    def __init__(self, client, annotationType=None, annotationValue=None, comments=None):
+    def __init__(self, client, annotationType=None, annotationValue=None, comments=None, metadata=None):
         super().__init__(client, None)
         self.annotation_type = annotationType
         self.annotation_value = annotationValue
         self.comments = comments
+        self.metadata = metadata
 
     def __repr__(self):
-        return f"Annotation(annotation_type={repr(self.annotation_type)},\n  annotation_value={repr(self.annotation_value)},\n  comments={repr(self.comments)})"
+        return f"Annotation(annotation_type={repr(self.annotation_type)},\n  annotation_value={repr(self.annotation_value)},\n  comments={repr(self.comments)},\n  metadata={repr(self.metadata)})"
 
     def to_dict(self):
         """
@@ -28,4 +30,4 @@ class Annotation(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'annotation_type': self.annotation_type, 'annotation_value': self.annotation_value, 'comments': self.comments}
+        return {'annotation_type': self.annotation_type, 'annotation_value': self.annotation_value, 'comments': self.comments, 'metadata': self.metadata}

{abacusai-0.62.1 → abacusai-0.63.1}/abacusai/annotation_config.py

@@ -11,17 +11,19 @@ class AnnotationConfig(AbstractApiClass):
             labels (list): List of labels
             statusFeature (str): Name of the feature that contains the status of the annotation (Optional)
             commentsFeature (str): Name of the feature that contains the comments for the annotation (Optional)
+            metadataFeature (str): Name of the feature that contains the metadata for the annotation (Optional)
     """
 
-    def __init__(self, client, featureAnnotationConfigs=None, labels=None, statusFeature=None, commentsFeature=None):
+    def __init__(self, client, featureAnnotationConfigs=None, labels=None, statusFeature=None, commentsFeature=None, metadataFeature=None):
         super().__init__(client, None)
         self.feature_annotation_configs = featureAnnotationConfigs
         self.labels = labels
         self.status_feature = statusFeature
         self.comments_feature = commentsFeature
+        self.metadata_feature = metadataFeature
 
     def __repr__(self):
-        return f"AnnotationConfig(feature_annotation_configs={repr(self.feature_annotation_configs)},\n  labels={repr(self.labels)},\n  status_feature={repr(self.status_feature)},\n  comments_feature={repr(self.comments_feature)})"
+        return f"AnnotationConfig(feature_annotation_configs={repr(self.feature_annotation_configs)},\n  labels={repr(self.labels)},\n  status_feature={repr(self.status_feature)},\n  comments_feature={repr(self.comments_feature)},\n  metadata_feature={repr(self.metadata_feature)})"
 
     def to_dict(self):
         """
@@ -30,4 +32,4 @@ class AnnotationConfig(AbstractApiClass):
         Returns:
             dict: The dict value representation of the class parameters
         """
-        return {'feature_annotation_configs': self.feature_annotation_configs, 'labels': self.labels, 'status_feature': self.status_feature, 'comments_feature': self.comments_feature}
+        return {'feature_annotation_configs': self.feature_annotation_configs, 'labels': self.labels, 'status_feature': self.status_feature, 'comments_feature': self.comments_feature, 'metadata_feature': self.metadata_feature}

{abacusai-0.62.1 → abacusai-0.63.1}/abacusai/api_client_utils.py

@@ -21,3 +21,27 @@ def get_clean_function_source_code(func: Callable):
     # If function source code has some initial indentation, remove it (Ex - can happen if the functor was defined inside a function)
     source_code = dedent(source_code)
     return source_code
+
+
+def avro_to_pandas_dtype(avro_type):
+    avro_pandas_dtypes = {
+        'long': 'Int64',
+        'int': 'Int32',
+        'float': 'float32',
+        'double': 'float64',
+        'string': 'object',
+        'boolean': 'bool',
+        'bytes': 'object',
+        'null': 'object',
+    }
+
+    if isinstance(avro_type, dict):
+        avro_type = avro_type['type']
+
+    return avro_pandas_dtypes.get(avro_type, 'object')
+
+
+def get_non_nullable_type(types):
+    non_nullable_types = [
+        avro_type for avro_type in types if avro_type != 'null']
+    return non_nullable_types[0] if non_nullable_types else None

abacusai-0.63.1/abacusai/chat_message.py

@@ -0,0 +1,31 @@
+from .return_class import AbstractApiClass
+
+
+class ChatMessage(AbstractApiClass):
+    """
+        A single chat message with Abacus Chat.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            role (str): The role of the message sender
+            text (list): A list of text segments for the message
+            timestamp (str): The timestamp at which the message was sent
+    """
+
+    def __init__(self, client, role=None, text=None, timestamp=None):
+        super().__init__(client, None)
+        self.role = role
+        self.text = text
+        self.timestamp = timestamp
+
+    def __repr__(self):
+        return f"ChatMessage(role={repr(self.role)},\n  text={repr(self.text)},\n  timestamp={repr(self.timestamp)})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        return {'role': self.role, 'text': self.text, 'timestamp': self.timestamp}

abacusai-0.63.1/abacusai/chat_session.py

@@ -0,0 +1,60 @@
+from .chat_message import ChatMessage
+from .return_class import AbstractApiClass
+
+
+class ChatSession(AbstractApiClass):
+    """
+        A chat session with Abacus Chat.
+
+        Args:
+            client (ApiClient): An authenticated API Client instance
+            answer (str): The response from the chatbot
+            availableIndices (list[dict]): A list of indices that the chatbot has access to
+            chatSessionId (str): The chat session id
+            projectId (str): The project id associated with the chat session
+            chatHistory (ChatMessage): The chat history for the conversation
+    """
+
+    def __init__(self, client, answer=None, availableIndices=None, chatSessionId=None, projectId=None, chatHistory={}):
+        super().__init__(client, chatSessionId)
+        self.answer = answer
+        self.available_indices = availableIndices
+        self.chat_session_id = chatSessionId
+        self.project_id = projectId
+        self.chat_history = client._build_class(ChatMessage, chatHistory)
+
+    def __repr__(self):
+        return f"ChatSession(answer={repr(self.answer)},\n  available_indices={repr(self.available_indices)},\n  chat_session_id={repr(self.chat_session_id)},\n  project_id={repr(self.project_id)},\n  chat_history={repr(self.chat_history)})"
+
+    def to_dict(self):
+        """
+        Get a dict representation of the parameters in this class
+
+        Returns:
+            dict: The dict value representation of the class parameters
+        """
+        return {'answer': self.answer, 'available_indices': self.available_indices, 'chat_session_id': self.chat_session_id, 'project_id': self.project_id, 'chat_history': self._get_attribute_as_dict(self.chat_history)}
+
+    def get(self):
+        """
+        Gets a chat session from Abacus Chat.
+
+        Args:
+            chat_session_id (str): The chat session id
+
+        Returns:
+            ChatSession: The chat session with Abacus Chat
+        """
+        return self.client.get_chat_session(self.chat_session_id)
+
+    def send_chat_message(self, message: str):
+        """
+        Updates chat history with the response from a user message
+
+        Args:
+            message (str): Message you want to send to Abacus Chat
+
+        Returns:
+            ChatSession: The chat session with Abacus Chat
+        """
+        return self.client.send_chat_message(self.chat_session_id, message)