WIP

CHANGELOG.md

@@ -8,13 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Parameter `meta: dict` on `BaseEvent`.
+- `TableArtifact` for storing CSV data.
 
 ### Changed
 - **BREAKING**: Parameter `driver` on `BaseConversationMemory` renamed to `conversation_memory_driver`.
 - **BREAKING**: `BaseConversationMemory.add_to_prompt_stack` now takes a `prompt_driver` parameter.
 - **BREAKING**: `BaseConversationMemoryDriver.load` now returns `tuple[list[Run], Optional[dict]]`.
 - **BREAKING**: `BaseConversationMemoryDriver.store` now takes `runs: list[Run]` and `metadata: Optional[dict]` as input.
 - **BREAKING**: Parameter `file_path` on `LocalConversationMemoryDriver` renamed to `persist_file` and is now type `Optional[str]`.
+- **BREAKING**: `CsvLoader` now returns a `TableArtifact` instead of a `list[CsvRowArtifact]`.
 - `Defaults.drivers_config.conversation_memory_driver` now defaults to `LocalConversationMemoryDriver` instead of `None`.
 
 ### Fixed

docs/griptape-framework/data/artifacts.md

@@ -46,13 +46,6 @@ An [ImageArtifact](../../reference/griptape/artifacts/image_artifact.md) is used
 
 An [AudioArtifact](../../reference/griptape/artifacts/audio_artifact.md) allows the Framework to interact with audio content. An Audio Artifact includes binary audio content as well as metadata like format, duration, and prompt and model information for audio returned generative models. It inherits from [BlobArtifact](#blob).
 
-## Boolean
-
-A [BooleanArtifact](../../reference/griptape/artifacts/boolean_artifact.md) is used for passing boolean values around the framework.
-
-!!! info
-    Any object passed on init to `BooleanArtifact` will be coerced into a `bool` type. This might lead to unintended behavior: `BooleanArtifact("False").value is True`. Use [BooleanArtifact.parse_bool](../../reference/griptape/artifacts/boolean_artifact.md#griptape.artifacts.boolean_artifact.BooleanArtifact.parse_bool) to convert case-insensitive string literal values `"True"` and `"False"` into a `BooleanArtifact`: `BooleanArtifact.parse_bool("False").value is False`.
-
 ## Generic
 
 A [GenericArtifact](../../reference/griptape/artifacts/generic_artifact.md) can be used as an escape hatch for passing any type of data around the framework.

griptape/artifacts/__init__.py

@@ -1,32 +1,35 @@
 from .base_artifact import BaseArtifact
+from .base_system_artifact import BaseSystemArtifact
+from .base_media_artifact import BaseMediaArtifact
+
 from .error_artifact import ErrorArtifact
 from .info_artifact import InfoArtifact
 from .text_artifact import TextArtifact
 from .json_artifact import JsonArtifact
 from .blob_artifact import BlobArtifact
-from .boolean_artifact import BooleanArtifact
 from .csv_row_artifact import CsvRowArtifact
 from .list_artifact import ListArtifact
-from .media_artifact import MediaArtifact
 from .image_artifact import ImageArtifact
 from .audio_artifact import AudioArtifact
 from .action_artifact import ActionArtifact
 from .generic_artifact import GenericArtifact
+from .table_artifact import TableArtifact
 
 
 __all__ = [
     "BaseArtifact",
+    "BaseSystemArtifact",
+    "BaseMediaArtifact",
     "ErrorArtifact",
     "InfoArtifact",
     "TextArtifact",
     "JsonArtifact",
     "BlobArtifact",
-    "BooleanArtifact",
     "CsvRowArtifact",
     "ListArtifact",
-    "MediaArtifact",
     "ImageArtifact",
     "AudioArtifact",
     "ActionArtifact",
     "GenericArtifact",
+    "TableArtifact",
 ]

griptape/artifacts/action_artifact.py

@@ -5,15 +5,11 @@
 from attrs import define, field
 
 from griptape.artifacts import BaseArtifact
-from griptape.mixins import SerializableMixin
 
 if TYPE_CHECKING:
     from griptape.common import ToolAction
 
 
 @define()
-class ActionArtifact(BaseArtifact, SerializableMixin):
+class ActionArtifact(BaseArtifact):
     value: ToolAction = field(metadata={"serializable": True})
-
-    def __add__(self, other: BaseArtifact) -> ActionArtifact:
-        raise NotImplementedError

griptape/artifacts/audio_artifact.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from attrs import define
+from attrs import define, field
 
-from griptape.artifacts import MediaArtifact
+from griptape.artifacts import BaseMediaArtifact
 
 
 @define
-class AudioArtifact(MediaArtifact):
-    """AudioArtifact is a type of MediaArtifact representing audio."""
+class AudioArtifact(BaseMediaArtifact):
+    """AudioArtifact is a type of Media Artifact representing audio."""
 
-    media_type: str = "audio"
+    media_type: str = field(default="audio", kw_only=True, metadata={"serializable": True})

griptape/artifacts/base_artifact.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import json
 import uuid
-from abc import ABC, abstractmethod
+from abc import ABC
 from typing import TYPE_CHECKING, Any, Optional
 
 from attrs import Factory, define, field
@@ -25,22 +24,6 @@ class BaseArtifact(SerializableMixin, ABC):
     )
     value: Any = field()
 
-    @classmethod
-    def value_to_bytes(cls, value: Any) -> bytes:
-        if isinstance(value, bytes):
-            return value
-        else:
-            return str(value).encode()
-
-    @classmethod
-    def value_to_dict(cls, value: Any) -> dict:
-        dict_value = value if isinstance(value, dict) else json.loads(value)
-
-        return dict(dict_value.items())
-
-    def to_text(self) -> str:
-        return str(self.value)
-
     def __str__(self) -> str:
         return self.to_text()
 
@@ -50,5 +33,5 @@ def __bool__(self) -> bool:
     def __len__(self) -> int:
         return len(self.value)
 
-    @abstractmethod
-    def __add__(self, other: BaseArtifact) -> BaseArtifact: ...
+    def to_text(self) -> str:
+        return str(self.value)

griptape/artifacts/base_media_artifact.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import base64
+
+from attrs import define, field
+
+from griptape.artifacts import BaseArtifact
+
+
+@define
+class BaseMediaArtifact(BaseArtifact):
+    """BaseMediaArtifact is a type of Artifact that represents media (image, audio, video, etc.) and can be extended to support a specific media type.
+
+    Attributes:
+        value: Raw bytes representing media data.
+        media_type: Main type of an IANA media type, such as "text", "audio", or "image".
+        format: Subtype of an IANA media type, such as "plain", "mp3", or "jpeg".
+    """
+
+    value: bytes = field(metadata={"serializable": True})
+    media_type: str = field(kw_only=True, metadata={"serializable": True})
+    format: str = field(kw_only=True, metadata={"serializable": True})
+
+    @property
+    def mime_type(self) -> str:
+        return f"{self.media_type}/{self.format}"
+
+    @property
+    def base64(self) -> str:
+        return base64.b64encode(self.value).decode("utf-8")
+
+    def to_text(self) -> str:
+        return f"Media, type: {self.mime_type}, size: {len(self.value)} bytes"

griptape/artifacts/base_system_artifact.py

@@ -0,0 +1,7 @@
+from griptape.artifacts import BaseArtifact
+
+
+class BaseSystemArtifact(BaseArtifact):
+    """Base class for Artifacts specific to Griptape."""
+
+    ...

griptape/artifacts/blob_artifact.py

@@ -1,26 +1,27 @@
 from __future__ import annotations
 
-import os.path
-from typing import Optional
+from typing import Any
 
-from attrs import define, field
+from attrs import Converter, define, field
 
 from griptape.artifacts import BaseArtifact
 
 
 @define
 class BlobArtifact(BaseArtifact):
-    value: bytes = field(converter=BaseArtifact.value_to_bytes, metadata={"serializable": True})
-    dir_name: Optional[str] = field(default=None, kw_only=True, metadata={"serializable": True})
+    value: bytes = field(
+        converter=Converter(lambda value: BlobArtifact.value_to_bytes(value)),
+        metadata={"serializable": True},
+    )
     encoding: str = field(default="utf-8", kw_only=True)
     encoding_error_handler: str = field(default="strict", kw_only=True)
 
-    def __add__(self, other: BaseArtifact) -> BlobArtifact:
-        return BlobArtifact(self.value + other.value, name=self.name)
-
-    @property
-    def full_path(self) -> str:
-        return os.path.join(self.dir_name, self.name) if self.dir_name else self.name
+    @classmethod
+    def value_to_bytes(cls, value: Any) -> bytes:
+        if isinstance(value, bytes):
+            return value
+        else:
+            return str(value).encode()
 
     def to_text(self) -> str:
         return self.value.decode(encoding=self.encoding, errors=self.encoding_error_handler)

griptape/artifacts/csv_row_artifact.py

@@ -2,23 +2,30 @@
 
 import csv
 import io
+import json
+from typing import Any
 
-from attrs import define, field
+from attrs import Converter, define, field
 
-from griptape.artifacts import BaseArtifact, TextArtifact
+from griptape.artifacts import TextArtifact
 
 
 @define
 class CsvRowArtifact(TextArtifact):
-    value: dict[str, str] = field(converter=BaseArtifact.value_to_dict, metadata={"serializable": True})
+    value: dict[str, str] = field(
+        converter=Converter(lambda value: CsvRowArtifact.value_to_dict(value)), metadata={"serializable": True}
+    )
     delimiter: str = field(default=",", kw_only=True, metadata={"serializable": True})
 
-    def __add__(self, other: BaseArtifact) -> CsvRowArtifact:
-        return CsvRowArtifact(self.value | other.value)
-
     def __bool__(self) -> bool:
         return len(self) > 0
 
+    @classmethod
+    def value_to_dict(cls, value: Any) -> dict:
+        dict_value = value if isinstance(value, dict) else json.loads(value)
+
+        return dict(dict_value.items())
+
     def to_text(self) -> str:
         with io.StringIO() as csvfile:
             writer = csv.DictWriter(

griptape/artifacts/error_artifact.py

@@ -4,13 +4,10 @@
 
 from attrs import define, field
 
-from griptape.artifacts import BaseArtifact
+from griptape.artifacts import BaseSystemArtifact
 
 
 @define
-class ErrorArtifact(BaseArtifact):
+class ErrorArtifact(BaseSystemArtifact):
     value: str = field(converter=str, metadata={"serializable": True})
     exception: Optional[Exception] = field(default=None, kw_only=True, metadata={"serializable": False})
-
-    def __add__(self, other: BaseArtifact) -> ErrorArtifact:
-        return ErrorArtifact(self.value + other.value)

griptape/artifacts/generic_artifact.py

@@ -10,6 +10,3 @@
 @define
 class GenericArtifact(BaseArtifact):
     value: Any = field(metadata={"serializable": True})
-
-    def __add__(self, other: BaseArtifact) -> BaseArtifact:
-        raise NotImplementedError

griptape/artifacts/image_artifact.py

@@ -2,22 +2,22 @@
 
 from attrs import define, field
 
-from griptape.artifacts import MediaArtifact
+from griptape.artifacts import BaseMediaArtifact
 
 
 @define
-class ImageArtifact(MediaArtifact):
-    """ImageArtifact is a type of MediaArtifact representing an image.
+class ImageArtifact(BaseMediaArtifact):
+    """ImageArtifact is a type of Media Artifact representing an image.
 
     Attributes:
-        value: Raw bytes representing media data.
         media_type: The type of media, defaults to "image".
-        format: The format of the media, like png, jpeg, or gif.
-        name: Artifact name, generated using creation time and a random string.
-        model: Optionally specify the model used to generate the media.
-        prompt: Optionally specify the prompt used to generate the media.
+        width: The width of the image in pixels.
+        height: The height of the image in pixels.
     """
 
-    media_type: str = "image"
+    media_type: str = field(default="image", kw_only=True, metadata={"serializable": True})
     width: int = field(kw_only=True, metadata={"serializable": True})
     height: int = field(kw_only=True, metadata={"serializable": True})
+
+    def to_text(self) -> str:
+        return self.base64

griptape/artifacts/info_artifact.py

@@ -2,12 +2,9 @@
 
 from attrs import define, field
 
-from griptape.artifacts import BaseArtifact
+from griptape.artifacts import BaseSystemArtifact
 
 
 @define
-class InfoArtifact(BaseArtifact):
+class InfoArtifact(BaseSystemArtifact):
     value: str = field(converter=str, metadata={"serializable": True})
-
-    def __add__(self, other: BaseArtifact) -> InfoArtifact:
-        return InfoArtifact(self.value + other.value)

griptape/artifacts/json_artifact.py

@@ -1,21 +1,24 @@
 from __future__ import annotations
 
 import json
-from typing import Union
+from typing import Any, Union
 
-from attrs import define, field
+from attrs import Converter, define, field
 
 from griptape.artifacts import BaseArtifact
 
-Json = Union[dict[str, "Json"], list["Json"], str, int, float, bool, None]
-
 
 @define
 class JsonArtifact(BaseArtifact):
-    value: Json = field(converter=lambda v: json.loads(json.dumps(v)), metadata={"serializable": True})
+    Json = Union[dict[str, "Json"], list["Json"], str, int, float, bool, None]
+
+    value: Json = field(
+        converter=Converter(lambda value: JsonArtifact.value_to_dict(value)), metadata={"serializable": True}
+    )
+
+    @classmethod
+    def value_to_dict(cls, value: Any) -> dict:
+        return json.loads(json.dumps(value))
 
     def to_text(self) -> str:
         return json.dumps(self.value)
-
-    def __add__(self, other: BaseArtifact) -> JsonArtifact:
-        raise NotImplementedError