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

jaclang/compiler/passes/transform.py

@@ -22,7 +22,7 @@ class Alert:
     def __str__(self) -> str:
         """Return string representation of alert."""
         return (
-            f"{self.loc.mod_path}, line {self.loc.first_line},"
+            f" {self.loc.mod_path}, line {self.loc.first_line},"
             f" col {self.loc.col_start}: {self.msg}"
         )
 
@@ -40,7 +40,7 @@ class Transform(ABC, Generic[T]):
         prior: Optional[Transform] = None,
     ) -> None:
         """Initialize pass."""
-        self.logger = logging.getLogger(self.__class__.__module__)
+        self.logger = logging.getLogger(self.__class__.__name__)
         self.errors_had: list[Alert] = [] if not prior else prior.errors_had
         self.warnings_had: list[Alert] = [] if not prior else prior.warnings_had
         self.cur_node: AstNode = input_ir  # tracks current node during traversal
@@ -59,7 +59,6 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.errors_had.append(alrt)
-        # print("Error:", str(alrt))
         self.logger.error(str(alrt))
 
     def log_warning(self, msg: str, node_override: Optional[AstNode] = None) -> None:
@@ -70,5 +69,4 @@ class Transform(ABC, Generic[T]):
             self.__class__,
         )
         self.warnings_had.append(alrt)
-        # print("Warning:", str(alrt))
         self.logger.warning(str(alrt))

jaclang/{core/registry.py → compiler/semtable.py}

@@ -12,9 +12,7 @@ from typing import Optional
 class SemInfo:
     """Semantic information class."""
 
-    def __init__(
-        self, name: str, type: Optional[str] = None, semstr: Optional[str] = None
-    ) -> None:
+    def __init__(self, name: str, type: Optional[str] = None, semstr: str = "") -> None:
         """Initialize the class."""
         self.name = name
         self.type = type

jaclang/compiler/symtable.py

@@ -17,7 +17,7 @@ class SymbolType(Enum):
 
     MODULE = "module"  # LSP: Module
     MOD_VAR = "mod_var"  # LSP: Variable
-    VAR = "var"  # LSP: Variable
+    VAR = "variable"  # LSP: Variable
     IMM_VAR = "immutable"  # LSP: Constant
     ABILITY = "ability"  # LSP: Function
     OBJECT_ARCH = "object"  # LSP: Class
@@ -37,24 +37,13 @@ class SymbolType(Enum):
     BOOL = "bool"  # LSP: Boolean
     SEQUENCE = "sequence"  # LSP: Array
     NULL = "null"  # LSP: Null
+    UNKNOWN = "unknown"  # LSP: Unknown
 
     def __str__(self) -> str:
         """Stringify."""
         return self.value
 
 
-class SymbolInfo:
-    """Symbol Info."""
-
-    def __init__(
-        self, typ: str = "NoType", acc_tag: Optional[SymbolAccess] = None
-    ) -> None:  # noqa: ANN401
-        """Initialize."""
-        self.typ = typ
-        self.acc_tag: Optional[SymbolAccess] = acc_tag
-        self.typ_sym_table: Optional[SymbolTable] = None
-
-
 class SymbolAccess(Enum):
     """Symbol types."""
 
@@ -74,20 +63,19 @@ class Symbol:
 
     def __init__(
         self,
-        defn: ast.AstSymbolNode,
+        defn: ast.NameAtom,
         access: SymbolAccess,
         parent_tab: SymbolTable,
-        typ: Optional[type] = None,
     ) -> None:
         """Initialize."""
-        self.typ = typ
-        self.defn: list[ast.AstSymbolNode] = [defn]
-        defn.sym_link = self
-        self.access = access
+        self.defn: list[ast.NameAtom] = [defn]
+        self.uses: list[ast.NameAtom] = []
+        defn.sym = self
+        self.access: SymbolAccess = access
         self.parent_tab = parent_tab
 
     @property
-    def decl(self) -> ast.AstSymbolNode:
+    def decl(self) -> ast.NameAtom:
         """Get decl."""
         return self.defn[0]
 
@@ -99,19 +87,35 @@ class Symbol:
     @property
     def sym_type(self) -> SymbolType:
         """Get sym_type."""
-        return self.decl.sym_type
+        return self.decl.sym_category
 
-    def add_defn(self, node: ast.AstSymbolNode) -> None:
+    @property
+    def sym_dotted_name(self) -> str:
+        """Return a full path of the symbol."""
+        out = [self.defn[0].sym_name]
+        current_tab = self.parent_tab
+        while current_tab is not None:
+            out.append(current_tab.name)
+            if current_tab.has_parent():
+                current_tab = current_tab.parent
+            else:
+                break
+        out.reverse()
+        return ".".join(out)
+
+    def add_defn(self, node: ast.NameAtom) -> None:
         """Add defn."""
         self.defn.append(node)
-        node.sym_link = self
+        node.sym = self
+
+    def add_use(self, node: ast.NameAtom) -> None:
+        """Add use."""
+        self.uses.append(node)
+        node.sym = self
 
     def __repr__(self) -> str:
         """Repr."""
-        return (
-            f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, "
-            f"{self.typ}, {self.defn})"
-        )
+        return f"Symbol({self.sym_name}, {self.sym_type}, {self.access}, {self.defn})"
 
 
 class SymbolTable:
@@ -126,7 +130,7 @@ class SymbolTable:
         self.parent = parent if parent else self
         self.kid: list[SymbolTable] = []
         self.tab: dict[str, Symbol] = {}
-        self.uses: list[ast.AstSymbolNode] = []
+        self.inherit: list[SymbolTable] = []
 
     def has_parent(self) -> bool:
         """Check if has parent."""
@@ -142,6 +146,10 @@ class SymbolTable:
         """Lookup a variable in the symbol table."""
         if name in self.tab:
             return self.tab[name]
+        for i in self.inherit:
+            found = i.lookup(name, deep=False)
+            if found:
+                return found
         if deep and self.has_parent():
             return self.get_parent().lookup(name, deep)
         return None
@@ -164,7 +172,7 @@ class SymbolTable:
         )
         if node.sym_name not in self.tab:
             self.tab[node.sym_name] = Symbol(
-                defn=node,
+                defn=node.name_spec,
                 access=(
                     access_spec
                     if isinstance(access_spec, SymbolAccess)
@@ -173,8 +181,8 @@ class SymbolTable:
                 parent_tab=self,
             )
         else:
-            self.tab[node.sym_name].add_defn(node)
-        node.sym_link = self.tab[node.sym_name]
+            self.tab[node.sym_name].add_defn(node.name_spec)
+        node.name_spec.sym = self.tab[node.sym_name]
         return collision
 
     def find_scope(self, name: str) -> Optional[SymbolTable]:

jaclang/compiler/tests/test_parser.py

@@ -102,9 +102,9 @@ class TestLarkParser(TestCaseMicroSuite):
             "JacSource",
             "EmptyToken",
             "AstSymbolNode",
+            "AstSymbolStubNode",
             "AstImplNeedingNode",
             "AstAccessNode",
-            "TokenSymbol",
             "Literal",
             "AstDocNode",
             "AstSemStrNode",
@@ -119,7 +119,7 @@ class TestLarkParser(TestCaseMicroSuite):
             "ArchBlockStmt",
             "EnumBlockStmt",
             "CodeBlockStmt",
-            "NameSpec",
+            "NameAtom",
             "ArchSpec",
             "MatchPattern",
         ]

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.compiler.semtable import SemInfo, SemRegistry, SemScope
 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."
@@ -71,7 +108,7 @@ def get_info_types(
                 else None
             )
             info_str.append(
-                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}"
+                f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) = {get_object_string(incl[1])}".strip()
             )
     return ("\n".join(info_str), collected_types)
 
@@ -142,7 +179,7 @@ def get_type_explanation(
         if sem_info.type == "Enum" and isinstance(type_info, list):
             for enum_item in type_info:
                 type_info_str.append(
-                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)"
+                    f"{enum_item.semstr} ({enum_item.name}) (EnumItem)".strip()
                 )
             type_example[0] = type_example[0].replace("(", f".{enum_item.name}")
         elif sem_info.type in ["obj", "class", "node", "edge"] and isinstance(
@@ -152,7 +189,7 @@ def get_type_explanation(
                 if arch_item.type in ["obj", "class", "node", "edge"]:
                     continue
                 type_info_str.append(
-                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})"
+                    f"{arch_item.semstr} ({arch_item.name}) ({arch_item.type})".strip()
                 )
                 type_example.append(f"{arch_item.name}={arch_item.type}, ")
                 if arch_item.type and extract_non_primary_type(arch_item.type):
@@ -162,7 +199,7 @@ def get_type_explanation(
             else:
                 type_example.append(")")
         return (
-            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}",  # noqa: E501
+            f"{sem_info.semstr} ({sem_info.name}) ({sem_info.type}) eg:- {''.join(type_example)} -> {', '.join(type_info_str)}".strip(),  # noqa: E501
             set(type_info_types),
         )
     return None, None
@@ -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] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip()
+            )
+        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] if i[0] else ''} ({i[2]}) (Image) = ".strip(),
+                    },
+                    {"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] if i[0] else ''} ({i[2]}) ({typ_anno}) = {get_object_string(i[3])}".strip(),
+                }
+            )
+        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 → architype.py}

@@ -2,15 +2,13 @@
 
 from __future__ import annotations
 
-import unittest
+import types
 from dataclasses import dataclass, field
-from typing import Callable, Optional
+from typing import Any, 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
 
 
 @dataclass(eq=False)
@@ -57,6 +55,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)
@@ -229,7 +229,13 @@ class WalkerAnchor(ObjectAnchor):
 
     def visit_node(
         self,
-        nds: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        nds: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Walker visits node."""
         nd_list: list[NodeArchitype | EdgeArchitype]
@@ -251,7 +257,13 @@ class WalkerAnchor(ObjectAnchor):
 
     def ignore_node(
         self,
-        nds: list[NodeArchitype | EdgeArchitype] | NodeArchitype | EdgeArchitype,
+        nds: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
     ) -> bool:
         """Walker ignores node."""
         nd_list: list[NodeArchitype | EdgeArchitype]
@@ -354,11 +366,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 +399,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 +425,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 +461,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,92 +489,14 @@ class Root(NodeArchitype):
         self._jac_.edges = []
 
 
-class GenericEdge(EdgeArchitype):
-    """Generic Root Node."""
-
-    _jac_entry_funcs_ = []
-    _jac_exit_funcs_ = []
-
-
-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
-            )
+@dataclass(eq=False)
+class DSFunc:
+    """Data Spatial Function."""
 
-    @staticmethod
-    def add_test(test_fun: Callable) -> None:
-        """Create a new test."""
-        JacTestCheck.test_suite.addTest(unittest.FunctionTestCase(test_fun))
+    name: str
+    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
+    func: Callable[[Any, Any], Any] | None = None
 
-    def __getattr__(self, name: str) -> object:
-        """Make convenient check.Equal(...) etc."""
-        return getattr(JacTestCheck.test_case, name)
+    def resolve(self, cls: type) -> None:
+        """Resolve the function."""
+        self.func = getattr(cls, self.name)

jaclang/core/constructs.py

@@ -0,0 +1,44 @@
+"""Core constructs for Jac Language."""
+
+from __future__ import annotations
+
+
+from .architype import (
+    Architype,
+    DSFunc,
+    EdgeAnchor,
+    EdgeArchitype,
+    ElementAnchor,
+    GenericEdge,
+    NodeAnchor,
+    NodeArchitype,
+    ObjectAnchor,
+    Root,
+    WalkerAnchor,
+    WalkerArchitype,
+)
+from .context import ExecutionContext, exec_context
+from .memory import Memory, ShelveStorage
+from .test import JacTestCheck, JacTestResult, JacTextTestRunner
+
+__all__ = [
+    "ElementAnchor",
+    "ObjectAnchor",
+    "NodeAnchor",
+    "EdgeAnchor",
+    "WalkerAnchor",
+    "Architype",
+    "NodeArchitype",
+    "EdgeArchitype",
+    "WalkerArchitype",
+    "GenericEdge",
+    "Root",
+    "DSFunc",
+    "Memory",
+    "ShelveStorage",
+    "ExecutionContext",
+    "exec_context",
+    "JacTestResult",
+    "JacTextTestRunner",
+    "JacTestCheck",
+]