jaclang 0.7.23__py3-none-any.whl → 0.7.25__py3-none-any.whl

jaclang/plugin/plugin.md

@@ -0,0 +1,471 @@
+# **Override Plugin Implementations**
+
+
+## AccessValidation Related Methods
+### **`allow_root`**
+```python
+def allow_root(
+    architype: Architype,
+    root_id: UUID,
+    level: AccessLevel | int | str
+) -> None:
+    """Allow all access from target root graph to current Architype."""
+```
+### **`disallow_root`**
+```python
+def disallow_root(
+    architype: Architype,
+    root_id: UUID,
+    level: AccessLevel | int | str
+) -> None:
+    """Disallow all access from target root graph to current Architype."""
+```
+### **`unrestrict`**
+```python
+def unrestrict(
+    architype: Architype,
+    level: AccessLevel | int | str
+) -> None:
+    """Allow everyone to access current Architype."""
+```
+### **`restrict`**
+```python
+def restrict(
+    architype: Architype
+) -> None:
+    """Disallow others to access current Architype."""
+```
+### **`check_read_access`**
+```python
+def check_read_access(
+    to: Anchor
+) -> bool:
+    """Read Access Validation."""
+```
+### **`check_connect_access`**
+```python
+def check_connect_access(
+    to: Anchor
+) -> bool:
+    """Connect Access Validation."""
+```
+### **`check_write_access`**
+```python
+def check_write_access(
+    to: Anchor
+) -> bool:
+    """Write Access Validation."""
+```
+### **`check_access_level`**
+```python
+def check_access_level(
+    to: Anchor
+) -> AccessLevel:
+    """Access validation."""
+```
+
+
+## Node Related Methods
+### **`node_dot`**
+```python
+def node_dot(
+    node: NodeArchitype,
+    dot_file: Optional[str]
+) -> str:
+    """Generate Dot file for visualizing nodes and edges."""
+```
+### **`get_edges`**
+```python
+def get_edges(
+    node: NodeAnchor,
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    target_obj: Optional[list[NodeArchitype]],
+) -> list[EdgeArchitype]:
+    """Get edges connected to this node."""
+```
+### **`edges_to_nodes`**
+```python
+def edges_to_nodes(
+    node: NodeAnchor,
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    target_obj: Optional[list[NodeArchitype]],
+) -> list[NodeArchitype]:
+    """Get set of nodes connected to this node."""
+```
+### **`remove_edge`**
+```python
+def remove_edge(
+    node: NodeAnchor,
+    edge: EdgeAnchor
+) -> None:
+    """Remove reference without checking sync status."""
+```
+
+
+## Edge Related Methods
+### **`detach`**
+```python
+def detach(
+    edge: EdgeAnchor
+) -> None:
+    """Detach edge from nodes."""
+```
+
+
+## Walker Related Methods
+### **`visit_node`**
+```python
+def visit_node(
+    walker: WalkerArchitype,
+    expr: (
+    list[NodeArchitype | EdgeArchitype]
+    | list[NodeArchitype]
+    | list[EdgeArchitype]
+    | NodeArchitype
+    | EdgeArchitype
+    ),
+) -> bool:
+    """Include target node/edge to current walker's visit queue."""
+```
+### **`ignore`**
+```python
+def ignore(
+    walker: WalkerArchitype,
+    expr: (
+        list[NodeArchitype | EdgeArchitype]
+        | list[NodeArchitype]
+        | list[EdgeArchitype]
+        | NodeArchitype
+        | EdgeArchitype
+    ),
+) -> bool:
+    """Include target node/edge to current walker's ignored architype."""
+```
+### **`spawn_call`**
+```python
+def spawn_call(
+    op1: Architype,
+    op2: Architype
+) -> WalkerArchitype:
+    """Invoke data spatial call."""
+```
+### **`disengage`**
+```python
+def disengage(
+    walker: WalkerArchitype
+) -> bool:
+    """Disengaged current walker."""
+```
+
+
+## Builtin Related Methods
+### **`dotgen`**
+```python
+def dotgen(
+    node: NodeArchitype,
+    depth: int,
+    traverse: bool,
+    edge_type: Optional[list[str]],
+    bfs: bool,
+    edge_limit: int,
+    node_limit: int,
+    dot_file: Optional[str],
+) -> str:
+    """Print the dot graph."""
+```
+
+
+## Cmd Related Methods
+### **`create_cmd`**
+```python
+def create_cmd(
+) -> None:
+    """Create Jac CLI cmds."""
+```
+
+
+## Feature Related Methods
+### **`setup`**
+```python
+def setup(
+) -> None:
+    """Set Class References to Jac."""
+```
+### **`get_context`**
+```python
+def get_context(
+) -> ExecutionContext:
+    """Get current execution context."""
+```
+### **`get_object`**
+```python
+def get_object(
+    id: str
+) -> Architype | None:
+    """Get object by id."""
+```
+### **`object_ref`**
+```python
+def object_ref(
+    obj: Architype
+) -> str:
+    """Get object's id."""
+```
+### **`make_architype`**
+```python
+def make_architype(
+    cls: type,
+    arch_base: Type[Architype],
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc],
+) -> Type[Architype]:
+    """Create a obj architype."""
+```
+### **`make_obj`**
+```python
+def make_obj(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a obj architype."""
+```
+### **`make_node`**
+```python
+def make_node(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a node architype."""
+```
+### **`make_edge`**
+```python
+def make_edge(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a edge architype."""
+```
+### **`make_walker`**
+```python
+def make_walker(
+    on_entry: list[DSFunc],
+    on_exit: list[DSFunc]
+) -> Callable[[type], type]:
+    """Create a walker architype."""
+```
+### **`impl_patch_filename`**
+```python
+def impl_patch_filename(
+    file_loc: str,
+) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    """Update impl file location."""
+```
+### **`jac_import`**
+```python
+def jac_import(
+    target: str,
+    base_path: str,
+    absorb: bool,
+    cachable: bool,
+    mdl_alias: Optional[str],
+    override_name: Optional[str],
+    lng: Optional[str],
+    items: Optional[dict[str, Union[str, Optional[str]]]],
+    reload_module: Optional[bool],
+) -> tuple[types.ModuleType, ...]:
+    """Core Import Process."""
+```
+### **`create_test`**
+```python
+def create_test(
+    test_fun: Callable
+) -> Callable:
+    """Create a new test."""
+```
+### **`run_test`**
+```python
+def run_test(
+    filepath: str,
+    filter: Optional[str],
+    xit: bool,
+    maxfail: Optional[int],
+    directory: Optional[str],
+    verbose: bool,
+) -> int:
+    """Run the test suite in the specified .jac file."""
+```
+### **`elvis`**
+```python
+def elvis(
+    op1: Optional[T],
+    op2: T
+) -> T:
+    """Jac's elvis operator feature."""
+```
+### **`has_instance_default`**
+```python
+def has_instance_default(
+    gen_func: Callable[[], T]
+) -> T:
+    """Jac's has container default feature."""
+```
+### **`report`**
+```python
+def report(
+    expr: Any
+) -> Any:
+    """Jac's report stmt feature."""
+```
+### **`edge_ref`**
+```python
+def edge_ref(
+    node_obj: NodeArchitype | list[NodeArchitype],
+    target_obj: Optional[NodeArchitype | list[NodeArchitype]],
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+    edges_only: bool,
+) -> list[NodeArchitype] | list[EdgeArchitype]:
+    """Jac's apply_dir stmt feature."""
+```
+### **`connect`**
+```python
+def connect(
+    left: NodeArchitype | list[NodeArchitype],
+    right: NodeArchitype | list[NodeArchitype],
+    edge_spec: Callable[[NodeAnchor, NodeAnchor], EdgeArchitype],
+    edges_only: bool,
+) -> list[NodeArchitype] | list[EdgeArchitype]:
+    """Jac's connect operator feature.
+
+    Note: connect needs to call assign compr with tuple in op
+    """
+```
+### **`disconnect`**
+```python
+def disconnect(
+    left: NodeArchitype | list[NodeArchitype],
+    right: NodeArchitype | list[NodeArchitype],
+    dir: EdgeDir,
+    filter_func: Optional[Callable[[list[EdgeArchitype]], list[EdgeArchitype]]],
+) -> bool:
+    """Jac's disconnect operator feature."""
+```
+### **`assign_compr`**
+```python
+def assign_compr(
+    target: list[T],
+    attr_val: tuple[tuple[str], tuple[Any]]
+) -> list[T]:
+    """Jac's assign comprehension feature."""
+```
+### **`get_root`**
+```python
+def get_root(
+) -> Root:
+    """Get current root."""
+```
+### **`get_root_type`**
+```python
+def get_root_type(
+) -> Type[Root]:
+    """Get root type."""
+```
+### **`build_edge`**
+```python
+def build_edge(
+    is_undirected: bool,
+    conn_type: Optional[Type[EdgeArchitype] | EdgeArchitype],
+    conn_assign: Optional[tuple[tuple, tuple]],
+) -> Callable[[NodeAnchor, NodeAnchor], EdgeArchitype]:
+    """Build edge operator."""
+```
+### **`save`**
+```python
+def save(
+    obj: Architype | Anchor,
+) -> None:
+    """Save object."""
+```
+### **`destroy`**
+```python
+def destroy(
+    obj: Architype | Anchor,
+) -> None:
+    """Destroy object."""
+```
+### **`get_semstr_type`**
+```python
+def get_semstr_type(
+    file_loc: str,
+    scope: str,
+    attr: str,
+    return_semstr: bool
+) -> Optional[str]:
+    """Jac's get_semstr_type stmt feature."""
+```
+### **`obj_scope`**
+```python
+def obj_scope(
+    file_loc: str,
+    attr: str
+) -> str:
+    """Jac's get_semstr_type feature."""
+```
+### **`get_sem_type`**
+```python
+def get_sem_type(
+    file_loc: str,
+    attr: str
+) -> tuple[str | None, str | None]:
+    """Jac's get_semstr_type feature."""
+```
+### **`with_llm`**
+```python
+def with_llm(
+    file_loc: str,
+    model: Any,
+    model_params: dict[str, Any],
+    scope: str,
+    incl_info: list[tuple[str, str]],
+    excl_info: list[tuple[str, str]],
+    inputs: list[tuple[str, str, str, Any]],
+    outputs: tuple,
+    action: str,
+    _globals: dict,
+    _locals: Mapping,
+) -> Any:
+    """Jac's with_llm stmt feature."""
+```
+### **`gen_llm_body`**
+```python
+def gen_llm_body(
+    _pass: PyastGenPass,
+    node: ast.Ability
+) -> list[ast3.AST]:
+    """Generate the by LLM body."""
+```
+### **`by_llm_call`**
+```python
+def by_llm_call(
+    _pass: PyastGenPass,
+    model: ast3.AST,
+    model_params: dict[str, ast.Expr],
+    scope: ast3.AST,
+    inputs: Sequence[Optional[ast3.AST]],
+    outputs: Sequence[Optional[ast3.AST]] | ast3.Call,
+    action: Optional[ast3.AST],
+    include_info: list[tuple[str, ast3.AST]],
+    exclude_info: list[tuple[str, ast3.AST]],
+) -> ast3.Call:
+    """Return the LLM Call, e.g. _Jac.with_llm()."""
+```
+### **`get_by_llm_call_args`**
+```python
+def get_by_llm_call_args(
+    _pass: PyastGenPass,
+    node: ast.FuncCall
+) -> dict:
+    """Get the by LLM call args."""
+```

jaclang/plugin/spec.py

@@ -356,7 +356,7 @@ class JacFeatureSpec(
 
     @staticmethod
     @hookspec(firstresult=True)
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
         raise NotImplementedError
 
@@ -458,6 +458,7 @@ class JacFeatureSpec(
         raise NotImplementedError
 
     @staticmethod
+    @hookspec(firstresult=True)
     def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]:
         """Jac's get_semstr_type feature."""
         raise NotImplementedError

jaclang/runtimelib/context.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import unittest
 from contextvars import ContextVar
+from dataclasses import MISSING
 from typing import Any, Callable, Optional, cast
 from uuid import UUID
 
@@ -26,6 +27,7 @@ class ExecutionContext:
 
     mem: Memory
     reports: list[Any]
+    custom: Any = MISSING
     system_root: NodeAnchor
     root: NodeAnchor
     entry_node: NodeAnchor

jaclang/runtimelib/importer.py

@@ -344,14 +344,19 @@ class JacImporter(Importer):
                     cachable=spec.cachable,
                     reload=reload if reload else False,
                 )
+
+                # Since this is a compile time error, we can safely raise an exception here.
+                if not codeobj:
+                    raise ImportError(f"No bytecode found for {spec.full_target}")
+
                 try:
-                    if not codeobj:
-                        raise ImportError(f"No bytecode found for {spec.full_target}")
                     with sys_path_context(spec.caller_dir):
                         exec(codeobj, module.__dict__)
                 except Exception as e:
+                    logger.error(e)
                     logger.error(dump_traceback(e))
                     raise e
+
         import_return = ImportReturn(module, unique_loaded_items, self)
         if spec.items:
             import_return.process_items(

jaclang/runtimelib/machine.py

@@ -1,5 +1,7 @@
 """Jac Machine module."""
 
+from __future__ import annotations
+
 import inspect
 import marshal
 import os
@@ -12,6 +14,7 @@ from typing import Optional, Union
 from jaclang.compiler.absyntree import Module
 from jaclang.compiler.compile import compile_jac
 from jaclang.compiler.constant import Constants as Con
+from jaclang.compiler.semtable import SemRegistry
 from jaclang.runtimelib.architype import (
     Architype,
     EdgeArchitype,
@@ -70,6 +73,14 @@ class JacMachine:
             )
         return None
 
+    def get_sem_ir(self, mod_sem_ir: SemRegistry | None) -> None:
+        """Update semtable on the attached JacProgram."""
+        if self.jac_program and mod_sem_ir:
+            if self.jac_program.sem_ir:
+                self.jac_program.sem_ir.registry.update(mod_sem_ir.registry)
+            else:
+                self.jac_program.sem_ir = mod_sem_ir
+
     def load_module(self, module_name: str, module: types.ModuleType) -> None:
         """Load a module into the machine."""
         self.loaded_modules[module_name] = module
@@ -263,14 +274,18 @@ class JacMachine:
 
 
 class JacProgram:
-    """Class to hold the mod_bundle and bytecode for Jac modules."""
+    """Class to hold the mod_bundle bytecode and sem_ir for Jac modules."""
 
     def __init__(
-        self, mod_bundle: Optional[Module], bytecode: Optional[dict[str, bytes]]
+        self,
+        mod_bundle: Optional[Module],
+        bytecode: Optional[dict[str, bytes]],
+        sem_ir: Optional[SemRegistry],
     ) -> None:
         """Initialize the JacProgram object."""
         self.mod_bundle = mod_bundle
         self.bytecode = bytecode or {}
+        self.sem_ir = sem_ir if sem_ir else SemRegistry()
 
     def get_bytecode(
         self,
@@ -292,10 +307,10 @@ class JacProgram:
 
         result = compile_jac(full_target, cache_result=cachable)
         if result.errors_had or not result.ir.gen.py_bytecode:
-            logger.error(
-                f"While importing {len(result.errors_had)} errors"
-                f" found in {full_target}"
-            )
+            for alrt in result.errors_had:
+                # We're not logging here, it already gets logged as the errors were added to the errors_had list.
+                # Regardless of the logging, this needs to be sent to the end user, so we'll printing it to stderr.
+                logger.error(alrt.pretty_print())
             return None
         if result.ir.gen.py_bytecode is not None:
             return marshal.loads(result.ir.gen.py_bytecode)

jaclang/settings.py

@@ -58,6 +58,9 @@ class Settings:
         """Override settings from environment variables if available."""
         for key in [f.name for f in fields(self)]:
             env_value = os.getenv("JACLANG_" + key.upper())
+            env_value = (
+                env_value if env_value is not None else os.getenv("JAC_" + key.upper())
+            )
             if env_value is not None:
                 setattr(self, key, self.convert_type(env_value))
 

jaclang/tests/fixtures/builtin_dotgen.jac

@@ -27,11 +27,11 @@ with entry{
     d3=dotgen(b[2],edge_limit=5,depth=5);l3=d3|>len; #generate dot for all connected with b[1] node
     d4=dotgen(b[1],bfs=True,edge_type= ["Edge1"],node_limit=100,edge_limit=900,depth=300);l4=d4|>len; #generate dot from nodes with depth 3 connected with b[1] node
     d5=dotgen(b[1],node_limit=10,edge_limit=90);l5:=d5|>len; #generate dot from nodes with depth 3 connected with b[1] node
-    print(d1.count('a(val')==12,d1.count('#FFFFE0')==3,'Root' in d1,d1.count('GenericEdge')==30);
-    print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('GenericEdge')==42);
-    print(d3.count('a(val')==6,d3.count("GenericEdge")==5,d3.count('#F5E5FF')==1);
-    print(d4.count("a(val")==25,d4.count("GenericEdge")==66,d4.count('#FFF0F')==3);
-    print(d5.count("Edge1(val=6)")==2, d5.count("GenericEdge()")==24);
+    print(d1.count('a(val')==12,d1.count('#FFFFE0')==3,'Root' in d1,d1.count('label=""')==30);
+    print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('label=""')==42);
+    print(d3.count('a(val')==6,d3.count('label=""')==5,d3.count('#F5E5FF')==1);
+    print(d4.count("a(val")==25,d4.count('label=""')==66,d4.count('#FFF0F')==3);
+    print(d5.count("Edge1(val=6)")==2, d5.count('label=""')==24);
     # print(l3<l2);
     # print(d1);
     # print(d2);
@@ -39,4 +39,4 @@ with entry{
     # print(d4);
     # print(dotgen(node=b[2],bfs=True,depth=3.96,edge_limit=12,node_limit=12.96));
 
-}
+}

jaclang/tests/fixtures/enum_inside_archtype.jac

@@ -1,20 +1,25 @@
-obj outer{
-    has o1:int=9;
+obj outer {
+    has o1: int = 9;
 
-    obj inner{
-        has i1:int=8;
+    obj inner {
+        has i1: int = 8;
     }
-    can foo(){
+    can foo() {
         return 'foo';
     }
-    enum color{
+    enum  color {
         red,
         green,
-        blue
+        blue,
+        with entry {
+            print('Initializing role system..');
+        },
+        can foo -> str {
+            return 'Accessing privileged Data';
         }
-
+    }
 }
 
-with entry{
-    print(outer.color.green.value);
-}
+with entry {
+    print(outer.color.green.value, outer.color.foo());
+}