mojentic 0.5.0__tar.gz → 0.5.2__tar.gz

{mojentic-0.5.0/src/mojentic.egg-info → mojentic-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.5.0
+Version: 0.5.2
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/mojility/mojentic

{mojentic-0.5.0 → mojentic-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.5.0"
+version = "0.5.2"
 authors = [
     { name = "Stacey Vetzal", email = "stacey@vetzal.com" },
 ]

{mojentic-0.5.0 → mojentic-0.5.2}/src/mojentic/llm/message_composers.py

@@ -126,7 +126,7 @@ class MessageBuilder():
         content = self.file_gateway.read(file_path)
         return (f"File: {file_path}\n"
                 f"```{self.type_sensor.get_language(file_path)}\n"
-                f"{content}\n"
+                f"{content.strip()}\n"
                 f"```\n")
 
 
@@ -253,6 +253,58 @@ class MessageBuilder():
 
         return self
 
+    def load_content(self, file_path: Union[str, Path], template_values: Optional[Dict[str, Union[str, Path]]] = None) -> "MessageBuilder":
+        """
+        Load content from a file into the content field of the MessageBuilder.
+
+        This method reads the content of the specified file and sets it as the content
+        of the MessageBuilder, replacing any existing content. If template_values is provided,
+        placeholders in the content will be replaced with the corresponding values.
+
+        Parameters
+        ----------
+        file_path : Union[str, Path]
+            Path to the file to load content from. Can be a string or Path object.
+        template_values : Optional[Dict[str, Union[str, Path]]], optional
+            Dictionary of values used to replace placeholders in the content.
+            For example, if the content contains "{greeting}" and template_values is
+            {"greeting": "Hello, World!"}, then "{greeting}" will be replaced with
+            "Hello, World!".
+            If a value is a Path object, it will be treated as a file reference and the
+            content of that file will be used to replace the placeholder.
+            Default is None.
+
+        Returns
+        -------
+        MessageBuilder
+            The MessageBuilder instance for method chaining.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the specified file does not exist.
+        """
+        if isinstance(file_path, str):
+            file_path = Path(file_path)
+        if not self.file_gateway.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        self.content = self.file_gateway.read(file_path)
+
+        # Replace placeholders with template values if provided
+        if template_values:
+            for key, value in template_values.items():
+                if isinstance(value, Path):
+                    # If value is a Path, read the content of the file
+                    if not self.file_gateway.exists(value):
+                        raise FileNotFoundError(f"Template file not found: {value}")
+                    file_content = self.file_gateway.read(value).strip()
+                    self.content = self.content.replace(f"{{{key}}}", file_content)
+                else:
+                    # If value is a string, use it directly
+                    self.content = self.content.replace(f"{{{key}}}", value)
+
+        return self
+
     def build(self) -> LLMMessage:
         """
         Build the final LLMMessage from the accumulated content, images, and files.

{mojentic-0.5.0 → mojentic-0.5.2}/src/mojentic/llm/message_composers_spec.py

@@ -14,6 +14,14 @@ def file_gateway(mocker):
     file_gateway.is_binary.return_value = False
     return file_gateway
 
+@pytest.fixture
+def file_path():
+    return Path("/path/to/file.txt")
+
+@pytest.fixture
+def whitespace_file_content():
+    return "\n\n  \n  test file content with whitespace  \n\n  \n"
+
 
 @pytest.fixture
 def message_builder(file_gateway):
@@ -144,6 +152,30 @@ class DescribeMessageBuilder:
             assert "test file content" in result
             assert "```" in result
 
+        def should_strip_whitespace_from_file_content(self, message_builder, file_gateway, file_path, whitespace_file_content, mocker):
+            """
+            Given a MessageBuilder
+            When _file_content_partial is called with content that has whitespace above and below
+            Then it should strip the whitespace when putting it in code fences
+            """
+            # Use the fixtures instead of creating file path and content directly
+            file_gateway.read.return_value = whitespace_file_content
+            mocker.patch.object(message_builder.type_sensor, 'get_language', return_value='text')
+
+            result = message_builder._file_content_partial(file_path)
+
+            file_gateway.read.assert_called_with(file_path)
+            assert "File: /path/to/file.txt" in result
+            assert "```text" in result
+            assert "test file content with whitespace" in result
+            assert "```" in result
+            # Verify that the content in the code fence doesn't have leading/trailing whitespace
+            lines = result.split('\n')
+            code_fence_start_index = lines.index("```text")
+            code_fence_end_index = lines.index("```", code_fence_start_index + 1)
+            code_content = lines[code_fence_start_index + 1:code_fence_end_index]
+            assert code_content == ["test file content with whitespace"]
+
     class DescribeAddImageMethod:
         """
         Specifications for the add_image method
@@ -238,6 +270,63 @@ class DescribeMessageBuilder:
             assert matching_files[0] in message_builder.image_paths
             assert matching_files[1] in message_builder.image_paths
 
+    class DescribeLoadContentMethod:
+        """
+        Specifications for the load_content method
+        """
+
+        def should_load_content_from_file(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a file path
+            Then it should load the content from the file and set it as the content
+            """
+            result = message_builder.load_content(file_path)
+
+            file_gateway.read.assert_called_once_with(file_path)
+            assert message_builder.content == "test file content"
+            assert result is message_builder  # Returns self for method chaining
+
+        def should_convert_string_path_to_path_object(self, message_builder, file_gateway):
+            """
+            Given a MessageBuilder
+            When load_content is called with a string path
+            Then it should convert the string to a Path object
+            """
+            file_path_str = "/path/to/file.txt"
+
+            message_builder.load_content(file_path_str)
+
+            file_gateway.read.assert_called_once_with(Path(file_path_str))
+
+        def should_raise_error_if_file_not_found(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a non-existent file
+            Then it should raise a FileNotFoundError
+            """
+            file_gateway.exists.return_value = False
+
+            with pytest.raises(FileNotFoundError):
+                message_builder.load_content(file_path)
+
+        def should_replace_placeholders_with_template_values(self, message_builder, file_gateway, file_path):
+            """
+            Given a MessageBuilder
+            When load_content is called with a file path and template values
+            Then it should replace placeholders in the content with the corresponding values
+            """
+            # Set up the file content with placeholders
+            file_gateway.read.return_value = "Hello, {name}! Today is {day}."
+
+            # Call load_content with template values
+            template_values = {"name": "World", "day": "Monday"}
+            result = message_builder.load_content(file_path, template_values)
+
+            # Verify that placeholders were replaced
+            assert message_builder.content == "Hello, World! Today is Monday."
+            assert result is message_builder  # Returns self for method chaining
+
 
 class DescribeTypeSensor:
     """

{mojentic-0.5.0 → mojentic-0.5.2/src/mojentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.5.0
+Version: 0.5.2
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/mojility/mojentic