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

jaclang/core/context.py

@@ -0,0 +1,157 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+import unittest
+from contextvars import ContextVar
+from typing import Callable, Optional
+from uuid import UUID
+
+from .architype import Architype, Root
+from .memory import Memory, ShelveStorage
+
+
+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):
+    """Jac test result class."""
+
+    def __init__(
+        self,
+        stream,  # noqa
+        descriptions,  # noqa
+        verbosity: int,
+        max_failures: Optional[int] = None,
+    ) -> None:
+        """Initialize FailFastTestResult object."""
+        super().__init__(stream, descriptions, verbosity)  # noqa
+        self.failures_count = JacTestCheck.failcount
+        self.max_failures = max_failures
+
+    def addFailure(self, test, err) -> None:  # noqa
+        """Count failures and stop."""
+        super().addFailure(test, err)
+        self.failures_count += 1
+        if self.max_failures is not None and self.failures_count >= self.max_failures:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop the test execution."""
+        self.shouldStop = True
+
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    """Jac test runner class."""
+
+    def __init__(self, max_failures: Optional[int] = None, **kwargs) -> None:  # noqa
+        """Initialize JacTextTestRunner object."""
+        self.max_failures = max_failures
+        super().__init__(**kwargs)
+
+    def _makeResult(self) -> JacTestResult:  # noqa
+        """Override the method to return an instance of JacTestResult."""
+        return JacTestResult(
+            self.stream,
+            self.descriptions,
+            self.verbosity,
+            max_failures=self.max_failures,
+        )
+
+
+class JacTestCheck:
+    """Jac Testing and Checking."""
+
+    test_case = unittest.TestCase()
+    test_suite = unittest.TestSuite()
+    breaker = False
+    failcount = 0
+
+    @staticmethod
+    def reset() -> None:
+        """Clear the test suite."""
+        JacTestCheck.test_case = unittest.TestCase()
+        JacTestCheck.test_suite = unittest.TestSuite()
+
+    @staticmethod
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
+        """Run the test suite."""
+        verb = 2 if verbose else 1
+        runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
+        result = runner.run(JacTestCheck.test_suite)
+        if result.wasSuccessful():
+            print("Passed successfully.")
+        else:
+            fails = len(result.failures)
+            JacTestCheck.failcount += fails
+            JacTestCheck.breaker = (
+                (JacTestCheck.failcount >= maxfail) if maxfail else True
+            )
+
+    @staticmethod
+    def add_test(test_fun: Callable) -> None:
+        """Create a new test."""
+        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+
+    def __getattr__(self, name: str) -> object:
+        """Make convenient check.Equal(...) etc."""
+        return getattr(JacTestCheck.test_case, name)

jaclang/core/importer.py

@@ -11,7 +11,6 @@ from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
 from jaclang.core.utils import sys_path_context
-from jaclang.utils.log import logging
 
 
 def jac_importer(
@@ -21,7 +20,7 @@ def jac_importer(
     cachable: bool = True,
     mdl_alias: Optional[str] = None,
     override_name: Optional[str] = None,
-    mod_bundle: Optional[Module] = None,
+    mod_bundle: Optional[Module | str] = None,
     lng: Optional[str] = "jac",
     items: Optional[dict[str, Union[str, bool]]] = None,
 ) -> Optional[types.ModuleType]:
@@ -41,6 +40,14 @@ def jac_importer(
     elif not override_name and not package_path and module_name in sys.modules:
         return sys.modules[module_name]
 
+    valid_mod_bundle = (
+        sys.modules[mod_bundle].__jac_mod_bundle__
+        if isinstance(mod_bundle, str)
+        and mod_bundle in sys.modules
+        and "__jac_mod_bundle__" in sys.modules[mod_bundle].__dict__
+        else mod_bundle
+    )
+
     caller_dir = get_caller_dir(target, base_path, dir_path)
     full_target = path.normpath(path.join(caller_dir, file_name))
 
@@ -51,10 +58,10 @@ def jac_importer(
     else:
         module_name = override_name if override_name else module_name
         module = create_jac_py_module(
-            mod_bundle, module_name, package_path, full_target
+            valid_mod_bundle, module_name, package_path, full_target
         )
-        if mod_bundle:
-            codeobj = mod_bundle.mod_deps[full_target].gen.py_bytecode
+        if valid_mod_bundle:
+            codeobj = valid_mod_bundle.mod_deps[full_target].gen.py_bytecode
             codeobj = marshal.loads(codeobj) if isinstance(codeobj, bytes) else None
         else:
             gen_dir = path.join(caller_dir, Con.JAC_GEN_DIR)
@@ -69,9 +76,8 @@ def jac_importer(
             else:
                 result = compile_jac(full_target, cache_result=cachable)
                 if result.errors_had or not result.ir.gen.py_bytecode:
-                    for e in result.errors_had:
-                        print(e)
-                        logging.error(e)
+                    # for e in result.errors_had:
+                    #     print(e)
                     return None
                 else:
                     codeobj = marshal.loads(result.ir.gen.py_bytecode)
@@ -84,7 +90,10 @@ def jac_importer(
 
 
 def create_jac_py_module(
-    mod_bundle: Optional[Module], module_name: str, package_path: str, full_target: str
+    mod_bundle: Optional[Module | str],
+    module_name: str,
+    package_path: str,
+    full_target: str,
 ) -> types.ModuleType:
     """Create a module."""
     module = types.ModuleType(module_name)

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),

jaclang/core/memory.py

@@ -1,8 +1,11 @@
-"""Memory abstraction for jaseci plugin."""
+"""Core constructs for Jac Language."""
 
+from __future__ import annotations
+
+import shelve
 from uuid import UUID
 
-from jaclang.core.construct import Architype
+from .architype import Architype
 
 
 class Memory:
@@ -46,3 +49,51 @@ class Memory:
     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

jaclang/core/test.py

@@ -0,0 +1,90 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+import unittest
+from typing import Callable, Optional
+
+
+class JacTestResult(unittest.TextTestResult):
+    """Jac test result class."""
+
+    def __init__(
+        self,
+        stream,  # noqa
+        descriptions,  # noqa
+        verbosity: int,
+        max_failures: Optional[int] = None,
+    ) -> None:
+        """Initialize FailFastTestResult object."""
+        super().__init__(stream, descriptions, verbosity)  # noqa
+        self.failures_count = JacTestCheck.failcount
+        self.max_failures = max_failures
+
+    def addFailure(self, test, err) -> None:  # noqa
+        """Count failures and stop."""
+        super().addFailure(test, err)
+        self.failures_count += 1
+        if self.max_failures is not None and self.failures_count >= self.max_failures:
+            self.stop()
+
+    def stop(self) -> None:
+        """Stop the test execution."""
+        self.shouldStop = True
+
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    """Jac test runner class."""
+
+    def __init__(self, max_failures: Optional[int] = None, **kwargs) -> None:  # noqa
+        """Initialize JacTextTestRunner object."""
+        self.max_failures = max_failures
+        super().__init__(**kwargs)
+
+    def _makeResult(self) -> JacTestResult:  # noqa
+        """Override the method to return an instance of JacTestResult."""
+        return JacTestResult(
+            self.stream,
+            self.descriptions,
+            self.verbosity,
+            max_failures=self.max_failures,
+        )
+
+
+class JacTestCheck:
+    """Jac Testing and Checking."""
+
+    test_case = unittest.TestCase()
+    test_suite = unittest.TestSuite()
+    breaker = False
+    failcount = 0
+
+    @staticmethod
+    def reset() -> None:
+        """Clear the test suite."""
+        JacTestCheck.test_case = unittest.TestCase()
+        JacTestCheck.test_suite = unittest.TestSuite()
+
+    @staticmethod
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None:
+        """Run the test suite."""
+        verb = 2 if verbose else 1
+        runner = JacTextTestRunner(max_failures=maxfail, failfast=xit, verbosity=verb)
+        result = runner.run(JacTestCheck.test_suite)
+        if result.wasSuccessful():
+            print("Passed successfully.")
+        else:
+            fails = len(result.failures)
+            JacTestCheck.failcount += fails
+            JacTestCheck.breaker = (
+                (JacTestCheck.failcount >= maxfail) if maxfail else True
+            )
+
+    @staticmethod
+    def add_test(test_fun: Callable) -> None:
+        """Create a new test."""
+        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+
+    def __getattr__(self, name: str) -> object:
+        """Make convenient check.Equal(...) etc."""
+        return getattr(JacTestCheck.test_case, name)

jaclang/core/utils.py

@@ -8,10 +8,10 @@ from contextlib import contextmanager
 from typing import Callable, Iterator, TYPE_CHECKING
 
 import jaclang.compiler.absyntree as ast
-from jaclang.core.registry import SemScope
+from jaclang.compiler.semtable import SemScope
 
 if TYPE_CHECKING:
-    from jaclang.core.construct import NodeAnchor, NodeArchitype
+    from jaclang.core.constructs import NodeAnchor, NodeArchitype
 
 
 @contextmanager