jaclang 0.7.1__py3-none-any.whl → 0.7.2__py3-none-any.whl

jaclang/core/aott.py

@@ -4,18 +4,30 @@ AOTT: Automated Operational Type Transformation.
 This has all the necessary functions to perform the AOTT operations.
 """
 
+import base64
+import logging
 import re
 from enum import Enum
+from io import BytesIO
 from typing import Any
 
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
 from jaclang.core.llms.base import BaseLLM
 from jaclang.core.registry import SemInfo, SemRegistry, SemScope
 
 
+IMG_FORMATS = ["PngImageFile", "JpegImageFile"]
+
+
 def aott_raise(
     model: BaseLLM,
     information: str,
-    inputs_information: str,
+    inputs_information: str | list[dict],
     output_information: str,
     type_explanations: str,
     action: str,
@@ -25,18 +37,43 @@ def aott_raise(
     model_params: dict,
 ) -> str:
     """AOTT Raise uses the information (Meanings types values) provided to generate a prompt(meaning in)."""
+    system_prompt = model.MTLLM_SYSTEM_PROMPT
+    meaning_in: str | list[dict]
     if method != "ReAct":
-        system_prompt = model.MTLLM_SYSTEM_PROMPT
-        mtllm_prompt = model.MTLLM_PROMPT.format(
-            information=information,
-            inputs_information=inputs_information,
-            output_information=output_information,
-            type_explanations=type_explanations,
-            action=action,
-            context=context,
-        )
         method_prompt = model.MTLLM_METHOD_PROMPTS[method]
-        meaning_in = f"{system_prompt}\n{mtllm_prompt}\n{method_prompt}"
+        if isinstance(inputs_information, str):
+            mtllm_prompt = model.MTLLM_PROMPT.format(
+                information=information,
+                inputs_information=inputs_information,
+                output_information=output_information,
+                type_explanations=type_explanations,
+                action=action,
+                context=context,
+            ).strip()
+            meaning_in = f"{system_prompt}\n{mtllm_prompt}\n{method_prompt}".strip()
+        else:
+            upper_half = model.MTLLM_PROMPT.split("{inputs_information}")[0]
+            lower_half = model.MTLLM_PROMPT.split("{inputs_information}")[1]
+            upper_half = upper_half.format(
+                information=information,
+                context=context,
+            )
+            lower_half = lower_half.format(
+                output_information=output_information,
+                type_explanations=type_explanations,
+                action=action,
+            )
+            meaning_in = (
+                [
+                    {"type": "text", "text": system_prompt},
+                    {"type": "text", "text": upper_half},
+                ]
+                + inputs_information
+                + [
+                    {"type": "text", "text": lower_half},
+                    {"type": "text", "text": method_prompt},
+                ]
+            )
         return model(meaning_in, **model_params)
     else:
         assert tools, "Tools must be provided for the ReAct method."
@@ -212,3 +249,62 @@ class Tool:
         """Initialize the Tool class."""
         # TODO: Implement the Tool class
         pass
+
+
+def get_input_information(
+    inputs: list[tuple[str, str, str, Any]], type_collector: list
+) -> str | list[dict]:
+    """
+    Get the input information for the AOTT operation.
+
+    Returns:
+        str | list[dict]: If the input does not contain images, returns a string with the input information.
+            If the input contains images, returns a list of dictionaries representing the input information,
+            where each dictionary contains either text or image_url.
+
+    """
+    contains_imgs = any(get_type_annotation(i[3]) in IMG_FORMATS for i in inputs)
+    if not contains_imgs:
+        inputs_information_list = []
+        for i in inputs:
+            typ_anno = get_type_annotation(i[3])
+            type_collector.extend(extract_non_primary_type(typ_anno))
+            inputs_information_list.append(
+                f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}"
+            )
+        return "\n".join(inputs_information_list)
+    else:
+        inputs_information_dict_list: list[dict] = []
+        for i in inputs:
+            if get_type_annotation(i[3]) in IMG_FORMATS:
+                img_base64 = image_to_base64(i[3])
+                image_repr: list[dict] = [
+                    {
+                        "type": "text",
+                        "text": f"{i[0]} ({i[2]}) (Image) = ",
+                    },
+                    {"type": "image_url", "image_url": {"url": img_base64}},
+                ]
+                inputs_information_dict_list.extend(image_repr)
+                continue
+            typ_anno = get_type_annotation(i[3])
+            type_collector.extend(extract_non_primary_type(typ_anno))
+            inputs_information_dict_list.append(
+                {
+                    "type": "text",
+                    "text": f"{i[0]} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}",
+                }
+            )
+        return inputs_information_dict_list
+
+
+def image_to_base64(image: Image) -> str:
+    """Convert an image to base64 expected by OpenAI."""
+    if not Image:
+        log = logging.getLogger(__name__)
+        log.error("Pillow is not installed. Please install Pillow to use images.")
+        return ""
+    img_format = image.format
+    with BytesIO() as buffer:
+        image.save(buffer, format=img_format, quality=100)
+        return f"data:image/{img_format.lower()};base64,{base64.b64encode(buffer.getvalue()).decode()}"

jaclang/core/construct.py

@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
+import shelve
 import unittest
+from contextvars import ContextVar
 from dataclasses import dataclass, field
 from typing import Callable, Optional
 from uuid import UUID, uuid4
 
 from jaclang.compiler.constant import EdgeDir
 from jaclang.core.utils import collect_node_connections
-from jaclang.plugin.feature import JacFeature as Jac
 from jaclang.plugin.spec import DSFunc
 
 
@@ -57,6 +58,8 @@ class NodeAnchor(ObjectAnchor):
 
     def populate_edges(self) -> None:
         """Populate edges from edge ids."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         if len(self.edges) == 0 and len(self.edge_ids) > 0:
             for e_id in self.edge_ids:
                 edge = Jac.context().get_obj(e_id)
@@ -354,11 +357,15 @@ class NodeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create node architype."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_: NodeAnchor = NodeAnchor(obj=self)
         Jac.context().save_obj(self, persistent=self._jac_.persistent)
 
     def save(self) -> None:
         """Save the node to the memory/storage hierarchy."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_.persistent = True
         Jac.context().save_obj(self, persistent=True)
 
@@ -383,11 +390,15 @@ class EdgeArchitype(Architype):
 
     def __init__(self) -> None:
         """Create edge architype."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self._jac_: EdgeAnchor = EdgeAnchor(obj=self)
         Jac.context().save_obj(self, persistent=self.persistent)
 
     def save(self) -> None:
         """Save the edge to the memory/storage hierarchy."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         self.persistent = True
         Jac.context().save_obj(self, persistent=True)
 
@@ -405,6 +416,8 @@ class EdgeArchitype(Architype):
 
     def populate_nodes(self) -> None:
         """Populate nodes for the edges from node ids."""
+        from jaclang.plugin.feature import JacFeature as Jac
+
         if self._jac_.source_id:
             obj = Jac.context().get_obj(self._jac_.source_id)
             if obj is None:
@@ -439,6 +452,13 @@ class WalkerArchitype(Architype):
         self._jac_: WalkerAnchor = WalkerAnchor(obj=self)
 
 
+class GenericEdge(EdgeArchitype):
+    """Generic Root Node."""
+
+    _jac_entry_funcs_ = []
+    _jac_exit_funcs_ = []
+
+
 class Root(NodeArchitype):
     """Generic Root Node."""
 
@@ -460,11 +480,157 @@ class Root(NodeArchitype):
         self._jac_.edges = []
 
 
-class GenericEdge(EdgeArchitype):
-    """Generic Root Node."""
+class Memory:
+    """Memory module interface."""
 
-    _jac_entry_funcs_ = []
-    _jac_exit_funcs_ = []
+    mem: dict[UUID, Architype] = {}
+    save_obj_list: dict[UUID, Architype] = {}
+
+    def __init__(self) -> None:
+        """init."""
+        pass
+
+    def get_obj(self, obj_id: UUID) -> Architype | None:
+        """Get object from memory."""
+        return self.get_obj_from_store(obj_id)
+
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
+        """Get object from the underlying store."""
+        ret = self.mem.get(obj_id)
+        return ret
+
+    def has_obj(self, obj_id: UUID) -> bool:
+        """Check if the object exists."""
+        return self.has_obj_in_store(obj_id)
+
+    def has_obj_in_store(self, obj_id: UUID) -> bool:
+        """Check if the object exists in the underlying store."""
+        return obj_id in self.mem
+
+    def save_obj(self, item: Architype, persistent: bool) -> None:
+        """Save object."""
+        self.mem[item._jac_.id] = item
+        if persistent:
+            # TODO: check if it needs to be saved, i.e. dirty or not
+            self.save_obj_list[item._jac_.id] = item
+
+    def commit(self) -> None:
+        """Commit changes to persistent storage, if applicable."""
+        pass
+
+    def close(self) -> None:
+        """Close any connection, if applicable."""
+        self.mem.clear()
+
+
+class ShelveStorage(Memory):
+    """Shelve storage for jaclang runtime object."""
+
+    storage: shelve.Shelf | None = None
+
+    def __init__(self, session: str = "") -> None:
+        """Init shelve storage."""
+        super().__init__()
+        if session:
+            self.connect(session)
+
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None:
+        """Get object from the underlying store."""
+        obj = super().get_obj_from_store(obj_id)
+        if obj is None and self.storage:
+            obj = self.storage.get(str(obj_id))
+            if obj is not None:
+                self.mem[obj_id] = obj
+
+        return obj
+
+    def has_obj_in_store(self, obj_id: UUID | str) -> bool:
+        """Check if the object exists in the underlying store."""
+        return obj_id in self.mem or (
+            str(obj_id) in self.storage if self.storage else False
+        )
+
+    def commit(self) -> None:
+        """Commit changes to persistent storage."""
+        if self.storage is not None:
+            for obj_id, obj in self.save_obj_list.items():
+                self.storage[str(obj_id)] = obj
+        self.save_obj_list.clear()
+
+    def connect(self, session: str) -> None:
+        """Connect to storage."""
+        self.session = session
+        self.storage = shelve.open(session)
+
+    def close(self) -> None:
+        """Close the storage."""
+        super().close()
+        self.commit()
+        if self.storage:
+            self.storage.close()
+        self.storage = None
+
+
+class ExecutionContext:
+    """Default Execution Context implementation."""
+
+    mem: Optional[Memory]
+    root: Optional[Root]
+
+    def __init__(self) -> None:
+        """Create execution context."""
+        super().__init__()
+        self.mem = ShelveStorage()
+        self.root = None
+
+    def init_memory(self, session: str = "") -> None:
+        """Initialize memory."""
+        if session:
+            self.mem = ShelveStorage(session)
+        else:
+            self.mem = Memory()
+
+    def get_root(self) -> Root:
+        """Get the root object."""
+        if self.mem is None:
+            raise ValueError("Memory not initialized")
+
+        if not self.root:
+            root = self.mem.get_obj(UUID(int=0))
+            if root is None:
+                self.root = Root()
+                self.mem.save_obj(self.root, persistent=self.root._jac_.persistent)
+            elif not isinstance(root, Root):
+                raise ValueError(f"Invalid root object: {root}")
+            else:
+                self.root = root
+        return self.root
+
+    def get_obj(self, obj_id: UUID) -> Architype | None:
+        """Get object from memory."""
+        if self.mem is None:
+            raise ValueError("Memory not initialized")
+
+        return self.mem.get_obj(obj_id)
+
+    def save_obj(self, item: Architype, persistent: bool) -> None:
+        """Save object to memory."""
+        if self.mem is None:
+            raise ValueError("Memory not initialized")
+
+        self.mem.save_obj(item, persistent)
+
+    def reset(self) -> None:
+        """Reset the execution context."""
+        if self.mem:
+            self.mem.close()
+        self.mem = None
+        self.root = None
+
+
+exec_context: ContextVar[ExecutionContext | None] = ContextVar(
+    "ExecutionContext", default=None
+)
 
 
 class JacTestResult(unittest.TextTestResult):

jaclang/core/llms/anthropic.py

@@ -45,12 +45,41 @@ class Anthropic(BaseLLM):
         self.client = anthropic.Anthropic()
         self.verbose = verbose
         self.max_tries = max_tries
-        self.model_name = kwargs.get("model_name", "claude-3-sonnet-20240229")
+        self.model_name = str(kwargs.get("model_name", "claude-3-sonnet-20240229"))
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        if not isinstance(meaning_in, str):
+            assert self.model_name.startswith(
+                ("claude-3-opus", "claude-3-sonnet", "claude-3-haiku")
+            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
+
+            import re
+
+            formatted_meaning_in = []
+            for item in meaning_in:
+                if item["type"] == "image_url":
+                    # "data:image/jpeg;base64,base64_string"
+                    img_match = re.match(
+                        r"data:(image/[a-zA-Z]*);base64,(.*)", item["source"]
+                    )
+                    if img_match:
+                        media_type, base64_string = img_match.groups()
+                    formatted_meaning_in.append(
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": media_type,
+                                "data": base64_string,
+                            },
+                        }
+                    )
+                    continue
+                formatted_meaning_in.append(item)
+            meaning_in = formatted_meaning_in
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.messages.create(
             model=kwargs.get("model_name", self.model_name),

jaclang/core/llms/base.py

@@ -112,11 +112,11 @@ class BaseLLM:
         self.max_tries = max_tries
         raise NotImplementedError
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
         raise NotImplementedError
 
-    def __call__(self, input_text: str, **kwargs: dict) -> str:
+    def __call__(self, input_text: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input text."""
         if self.verbose:
             logger.info(f"Meaning In\n{input_text}")
@@ -131,7 +131,7 @@ class BaseLLM:
     ) -> str:
         """Resolve the output string to return the reasoning and output."""
         if self.verbose:
-            logger.opt(colors=True).info(f"Meaning Out\n<green>{meaning_out}</green>")
+            logger.info(f"Meaning Out\n{meaning_out}")
         output_match = re.search(r"\[Output\](.*)", meaning_out)
         output = output_match.group(1).strip() if output_match else None
         if not output_match:

jaclang/core/llms/groq.py

@@ -49,8 +49,11 @@ class Groq(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         model_params = {
             k: v

jaclang/core/llms/huggingface.py

@@ -61,8 +61,11 @@ class Huggingface(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_new_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.pipe(
             messages,

jaclang/core/llms/ollama.py

@@ -51,8 +51,11 @@ class Ollama(BaseLLM):
             k: v for k, v in kwargs.items() if k not in ["model_name", "host"]
         }
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         model = str(kwargs.get("model_name", self.model_name))
         if not self.check_model(model):
             self.download_model(model)

jaclang/core/llms/openai.py

@@ -45,12 +45,16 @@ class OpenAI(BaseLLM):
         self.client = openai.OpenAI()
         self.verbose = verbose
         self.max_tries = max_tries
-        self.model_name = kwargs.get("model_name", "gpt-3.5-turbo")
+        self.model_name = str(kwargs.get("model_name", "gpt-3.5-turbo"))
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        if not isinstance(meaning_in, str):
+            assert self.model_name.startswith(
+                ("gpt-4o", "gpt-4-turbo")
+            ), f"Model {self.model_name} is not multimodal, use a multimodal model instead."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.chat.completions.create(
             model=kwargs.get("model_name", self.model_name),

jaclang/core/llms/togetherai.py

@@ -48,8 +48,11 @@ class TogetherAI(BaseLLM):
         self.temperature = kwargs.get("temperature", 0.7)
         self.max_tokens = kwargs.get("max_tokens", 1024)
 
-    def __infer__(self, meaning_in: str, **kwargs: dict) -> str:
+    def __infer__(self, meaning_in: str | list[dict], **kwargs: dict) -> str:
         """Infer a response from the input meaning."""
+        assert isinstance(
+            meaning_in, str
+        ), "Currently Multimodal models are not supported. Please provide a string input."
         messages = [{"role": "user", "content": meaning_in}]
         output = self.client.chat.completions.create(
             model=kwargs.get("model_name", self.model_name),