mojentic 0.4.2__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.4.2
+Version: 0.5.0
 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
@@ -15,6 +15,7 @@ Requires-Dist: pydantic
 Requires-Dist: structlog
 Requires-Dist: ollama
 Requires-Dist: openai
+Requires-Dist: anthropic
 Requires-Dist: tiktoken
 Requires-Dist: parsedatetime
 Requires-Dist: pytz

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

@@ -1,6 +1,6 @@
 [project]
 name = "mojentic"
-version = "0.4.2"
+version = "0.5.0"
 authors = [
     { name = "Stacey Vetzal", email = "stacey@vetzal.com" },
 ]
@@ -18,6 +18,7 @@ dependencies = [
     "structlog",
     "ollama",
     "openai",
+    "anthropic",
     "tiktoken",
     "parsedatetime",
     "pytz",

mojentic-0.5.0/src/_examples/current_datetime_tool_example.py

@@ -0,0 +1,28 @@
+from mojentic.llm.gateways.models import LLMMessage
+from mojentic.llm.llm_broker import LLMBroker
+from mojentic.llm.tools.current_datetime import CurrentDateTimeTool
+
+# Create an LLM broker with a specified model
+# You can change the model to any supported model
+llm = LLMBroker(model="qwen2.5:7b")  # Using the same model as in simple_tool.py
+
+# Create our custom tool
+datetime_tool = CurrentDateTimeTool()
+
+# Generate a response with tool assistance
+result = llm.generate(
+    messages=[LLMMessage(content="What time is it right now? Also, what day of the week is it today?")],
+    tools=[datetime_tool]
+)
+
+print("LLM Response:")
+print(result)
+
+# You can also try with a custom format string
+result = llm.generate(
+    messages=[LLMMessage(content="Tell me the current date in a friendly format, like 'Monday, January 1, 2023'")],
+    tools=[datetime_tool]
+)
+
+print("\nLLM Response with custom format:")
+print(result)

mojentic-0.5.0/src/_examples/design_analysis.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from mojentic.llm.gateways import OllamaGateway
+from mojentic.llm.gateways.models import LLMMessage
+
+llmg = OllamaGateway()
+
+
+def complete(prompt: str):
+    response = llmg.complete(
+        model="gemma3:27b",
+        messages=[
+            LLMMessage(
+                content=prompt.strip(),
+                image_paths=[
+                    str(Path.cwd() / "images" / "screen_cap.png")
+                ]
+            )
+        ],
+    )
+    return response.content
+
+
+# It's quite good at extracting text from images
+result = complete("Extract the text from the attached image in markdown format.")
+print(result)
+
+# It's not bad at extracting and structuring the text it finds in images
+result = complete("""
+Extract the title and text boxes from the attached image in the form of a JSON object.
+Use descriptive key names like `title` or `bullet` or `footer`. In the values, use html
+but don't attempt to convert all of the visual formatting, just simple formatting like
+paragraphs, bold, or italic.
+""")
+print(result)
+
+# Gemma3 is not very good at determining hex colours :)
+result = complete("""
+Extract the colours from the attached image in the form of a JSON object, where the key
+is the description of how the colour is used, and the value is the colour in hex format.
+""")
+print(result)

mojentic-0.5.0/src/_examples/ensures_files_exist.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+import sys
+import os
+
+from mojentic.llm.message_composers import MessageBuilder
+
+# Get the project root directory (2 levels up from the current script)
+project_root = Path(os.path.dirname(os.path.abspath(__file__))).parent.parent
+
+# Test adding non-existent image
+print("Testing adding non-existent image:")
+non_existent_image = project_root / 'src' / '_examples' / 'images' / 'non_existent_image.jpg'
+
+try:
+    message_builder = MessageBuilder("Testing non-existent image")
+    message_builder.add_image(non_existent_image)
+    print("ERROR: Expected FileNotFoundError was not raised")
+    sys.exit(1)
+except FileNotFoundError as e:
+    print(f"Success: Caught expected exception: {e}")
+
+# Test adding non-existent file
+print("\nTesting adding non-existent file:")
+non_existent_file = project_root / 'src' / '_examples' / 'non_existent_file.py'
+
+try:
+    message_builder = MessageBuilder("Testing non-existent file")
+    message_builder.add_file(non_existent_file)
+    print("ERROR: Expected FileNotFoundError was not raised")
+    sys.exit(1)
+except FileNotFoundError as e:
+    print(f"Success: Caught expected exception: {e}")
+
+# Test adding existing image
+print("\nTesting adding existing image:")
+existing_image = project_root / 'src' / '_examples' / 'images' / 'xbox-one.jpg'
+
+try:
+    message_builder = MessageBuilder("Testing existing image")
+    message_builder.add_image(existing_image)
+    print("Success: Added existing image without exception")
+except FileNotFoundError as e:
+    print(f"ERROR: Unexpected exception: {e}")
+    sys.exit(1)
+
+# Test adding existing file
+print("\nTesting adding existing file:")
+existing_file = Path(__file__)  # This file itself (absolute path)
+
+try:
+    message_builder = MessageBuilder("Testing existing file")
+    message_builder.add_file(existing_file)
+    print("Success: Added existing file without exception")
+except FileNotFoundError as e:
+    print(f"ERROR: Unexpected exception: {e}")
+    sys.exit(1)
+
+print("\nAll tests passed!")

mojentic-0.5.0/src/_examples/file_deduplication.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from mojentic.llm.message_composers import MessageBuilder
+
+# Test de-duplication of images
+print("Testing image de-duplication:")
+image_path = Path.cwd() / 'src' / '_examples' / 'images' / 'xbox-one.jpg'
+
+# Create a message builder and add the same image multiple times
+message_builder = MessageBuilder("Testing image de-duplication")
+message_builder.add_image(image_path)
+message_builder.add_image(image_path)  # Adding the same image again
+message_builder.add_images(image_path, image_path)  # Adding the same image twice more
+
+# Build the message and check the number of images
+message = message_builder.build()
+print(f"Number of images in message: {len(message.image_paths)}")
+print(f"Expected number of images: 1")
+print(f"De-duplication working: {len(message.image_paths) == 1}")
+
+# Test de-duplication of files
+print("\nTesting file de-duplication:")
+file_path = Path('file_deduplication.py')  # This file itself
+
+# Create a message builder and add the same file multiple times
+message_builder = MessageBuilder("Testing file de-duplication")
+message_builder.add_file(file_path)
+message_builder.add_file(file_path)  # Adding the same file again
+message_builder.add_files(file_path, file_path)  # Adding the same file twice more
+
+# Build the message and check the number of files
+message = message_builder.build()
+# Since we're using the file content in the message, we need to check file_paths directly
+print(f"Number of files in message_builder.file_paths: {len(message_builder.file_paths)}")
+print(f"Expected number of files: 1")
+print(f"De-duplication working: {len(message_builder.file_paths) == 1}")
+
+print("\nTest completed.")

mojentic-0.5.0/src/_examples/image_broker.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.message_composers import MessagesBuilder, MessageBuilder
+
+llm = LLMBroker(model="gemma3:27b")
+
+message = MessageBuilder("What is in this image?") \
+    .add_image(Path.cwd() / 'images' / 'xbox-one.jpg') \
+    .build()
+
+result = llm.generate(messages=[message])
+
+print(result)

mojentic-0.5.0/src/_examples/image_broker_splat.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.message_composers import MessageBuilder
+
+# Initialize the LLM broker
+llm = LLMBroker(model="gemma3:27b")
+
+# Example 1: Adding multiple specific images using the splat operator
+print("Example 1: Adding multiple specific images")
+message1 = MessageBuilder("What are in these images?") \
+    .add_images(
+        Path.cwd() / 'images' / 'flash_rom.jpg',
+        Path.cwd() / 'images' / 'screen_cap.png'  # Assuming this file exists
+    ) \
+    .build()
+
+# Example 2: Adding all JPG images from a directory
+print("\nExample 2: Adding all JPG images from a directory")
+images_dir = Path.cwd() / 'images'
+message2 = MessageBuilder("Describe all these images:") \
+    .add_images(images_dir) \
+    .build()
+
+# Example 3: Using a glob pattern to add specific types of images
+print("\nExample 3: Using a glob pattern")
+message3 = MessageBuilder("What can you tell me about these images?") \
+    .add_images(Path.cwd() / 'images' / '*.jpg') \
+    .build()
+
+# Example 4: Combining different ways to specify images
+print("\nExample 4: Combining different ways to specify images")
+message4 = MessageBuilder("Analyze these images:") \
+    .add_images(
+        Path.cwd() / 'images' / 'xbox-one.jpg',  # Specific image
+        images_dir,                              # All JPGs in directory
+        Path.cwd() / 'images' / '*.png'          # All PNGs using glob pattern
+    ) \
+    .build()
+
+# Print the number of images added in each example
+print(f"Example 1: Added {len(message1.image_paths)} image(s)")
+print(f"Example 2: Added {len(message2.image_paths)} image(s)")
+print(f"Example 3: Added {len(message3.image_paths)} image(s)")
+print(f"Example 4: Added {len(message4.image_paths)} image(s)")
+
+# Generate a response using one of the messages (e.g., message1)
+print("\nGenerating response for Example 1...")
+result = llm.generate(messages=[message1])
+print(result)

{mojentic-0.4.2 → mojentic-0.5.0}/src/_examples/list_models.py

@@ -1,6 +1,7 @@
 import os
 
 from mojentic.llm.gateways import OllamaGateway, OpenAIGateway
+from mojentic.llm.gateways.anthropic import AnthropicGateway
 
 ollama = OllamaGateway()
 print("Ollama Models:")
@@ -12,4 +13,11 @@ print()
 openai = OpenAIGateway(os.environ["OPENAI_API_KEY"])
 print("OpenAI Models:")
 for model in openai.get_available_models():
-    print(f"- {model}")
+    print(f"- {model}")
+
+print()
+
+anthropic = AnthropicGateway(os.environ["ANTHROPIC_API_KEY"])
+print("Anthropic Models:")
+for model in anthropic.get_available_models():
+    print(f"- {model}")

mojentic-0.5.0/src/_examples/raw.py

@@ -0,0 +1,21 @@
+import os
+
+from anthropic import Anthropic
+
+client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+
+anthropic_args = {
+    'model': "claude-3-5-haiku-20241022",
+    'system': "You are a helpful assistant.",
+    'messages': [
+        {
+            "role": "user",
+            "content": "Say hello world",
+        }
+    ],
+    'max_tokens': 2000,
+}
+
+response = client.messages.create(**anthropic_args)
+
+print(response.content[0].text)

{mojentic-0.4.2 → mojentic-0.5.0}/src/mojentic/llm/__init__.py

@@ -1,3 +1,4 @@
 from .llm_broker import LLMBroker
 from .registry.llm_registry import LLMRegistry
 from .chat_session import ChatSession
+from .message_composers import MessageBuilder, FileTypeSensor

mojentic-0.5.0/src/mojentic/llm/gateways/anthropic.py

@@ -0,0 +1,52 @@
+from typing import List
+
+import structlog
+from anthropic import Anthropic
+
+from mojentic.llm.gateways import LLMGateway
+from mojentic.llm.gateways.models import LLMGatewayResponse, LLMToolCall, MessageRole
+from mojentic.llm.gateways.anthropic_messages_adapter import adapt_messages_to_anthropic
+
+logger = structlog.get_logger()
+
+class AnthropicGateway(LLMGateway):
+    def __init__(self, api_key: str):
+        self.client = Anthropic(api_key=api_key)
+
+    def complete(self, **args) -> LLMGatewayResponse:
+
+        messages = args.get('messages')
+
+        system_messages = [m for m in messages if m.role == MessageRole.System]
+        user_messages = [m for m in messages if m.role == MessageRole.User]
+
+        anthropic_args = {
+            'model': args['model'],
+            'system': " " . join([m.content for m in system_messages]) if system_messages else None,
+            'messages': adapt_messages_to_anthropic(user_messages),
+        }
+
+        response = self.client.messages.create(
+            **anthropic_args,
+            temperature=args.get('temperature', 1.0),
+            max_tokens=args.get('num_predict', 2000),
+            # thinking={
+            #     "type": "enabled",
+            #     "budget_tokens": 32768,
+            # }
+        )
+
+        object = None
+        tool_calls: List[LLMToolCall] = []
+
+        return LLMGatewayResponse(
+            content=response.content[0].text,
+            object=object,
+            tool_calls=tool_calls,
+        )
+
+    def get_available_models(self) -> List[str]:
+        return sorted([m.id for m in self.client.models.list()])
+
+    def calculate_embeddings(self, text: str, model: str = "voyage-3-large") -> List[float]:
+        raise NotImplementedError("The Anthropic API does not support embedding generation.")

mojentic-0.5.0/src/mojentic/llm/gateways/anthropic_messages_adapter.py

@@ -0,0 +1,72 @@
+import base64
+import json
+import os
+from typing import List, Any
+
+import structlog
+
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+
+logger = structlog.get_logger()
+
+
+def adapt_messages_to_anthropic(messages: List[LLMMessage]):
+    new_messages: List[dict[str, Any]] = []
+    for m in messages:
+        if m.role == MessageRole.System:
+            # System messages aren't supported by Anthropic
+            pass
+        elif m.role == MessageRole.User:
+            if m.image_paths is not None and len(m.image_paths) > 0:
+                # Create a content structure with text and images
+                content = []
+                if m.content:
+                    content.append({"type": "text", "text": m.content})
+
+                # Add each image as a base64-encoded URL
+                for image_path in m.image_paths:
+                    try:
+                        with open(image_path, "rb") as image_file:
+                            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
+
+                            # Determine image type from file extension
+                            _, ext = os.path.splitext(image_path)
+                            image_type = ext.lstrip('.').lower()
+                            if image_type not in ['jpeg', 'jpg', 'png', 'gif', 'webp']:
+                                image_type = 'jpeg'  # Default to jpeg if unknown extension
+
+                            content.append({
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": f"image/{image_type}",
+                                    "data": base64_image
+                                }
+                            })
+                    except Exception as e:
+                        logger.error("Failed to encode image", error=str(e), image_path=image_path)
+
+                new_messages.append({'role': 'user', 'content': content})
+            else:
+                new_messages.append({'role': 'user', 'content': m.content})
+        elif m.role == MessageRole.Assistant:
+            msg = {'role': 'assistant', 'content': m.content or ''}
+            # if m.tool_calls is not None:
+            #     msg['tool_calls'] = [{
+            #         'id': m.tool_calls[0].id,
+            #         'type': 'function',
+            #         'function': {
+            #             'name': m.tool_calls[0].name,
+            #             'arguments': json.dumps({k: v for k, v in m.tool_calls[0].arguments.items()})
+            #         }
+            #     }]
+            new_messages.append(msg)
+        # elif m.role == MessageRole.Tool:
+        #     new_messages.append({
+        #         'role': 'tool',
+        #         'content': m.content,
+        #         'tool_call_id': m.tool_calls[0].id
+        #     })
+        else:
+            logger.error("Unknown message role", role=m.role)
+    return new_messages

mojentic-0.5.0/src/mojentic/llm/gateways/file_gateway.py

@@ -0,0 +1,55 @@
+from pathlib import Path
+from typing import Union
+
+
+class FileGateway:
+
+    def read(self, path: Union[Path, str]):
+        if isinstance(path, str):
+            path = Path(path)
+        with open(path, 'r') as file:
+            return file.read()
+
+    def exists(self, path: Union[Path, str]) -> bool:
+        """
+        Check if a file exists.
+
+        Parameters
+        ----------
+        path : Union[Path, str]
+            Path to the file
+
+        Returns
+        -------
+        bool
+            True if the file exists, False otherwise
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        return path.exists()
+
+    def is_binary(self, path: Union[Path, str]) -> bool:
+        """
+        Check if a file is binary.
+
+        Parameters
+        ----------
+        path : Union[Path, str]
+            Path to the file
+
+        Returns
+        -------
+        bool
+            True if the file is binary, False otherwise
+        """
+        if isinstance(path, str):
+            path = Path(path)
+        try:
+            with open(path, 'rb') as file:
+                # Read the first 1024 bytes
+                chunk = file.read(1024)
+                # Check for null bytes, which are typically present in binary files
+                return b'\0' in chunk
+        except Exception:
+            # If there's an error reading the file, assume it's binary
+            return True

{mojentic-0.4.2 → mojentic-0.5.0}/src/mojentic/llm/gateways/openai.py

@@ -21,7 +21,7 @@ class OpenAIGateway(LLMGateway):
         The OpenAI API key to use.
     """
 
-    def __init__(self, api_key):
+    def __init__(self, api_key: str):
         self.client = OpenAI(api_key=api_key)
 
     def complete(self, **args) -> LLMGatewayResponse: