jaclang 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/langserve/tests/test_server.py

@@ -1,11 +1,12 @@
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
-from jaclang.langserve.engine import JacLangServer
-from .session import LspSession
 
 import lsprotocol.types as lspt
 import pytest
+from jaclang import JacMachineInterface as _
+from jaclang.langserve.engine import JacLangServer
+from .session import LspSession
 
 
 class TestJacLangServer(TestCase):
@@ -62,7 +63,7 @@ class TestJacLangServer(TestCase):
         self.assertIn(
             # "ability) calculate_area: float",
             "ability) calculate_area\n( radius : float ) -> float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
     def test_impl_auto_discover(self) -> None:
@@ -80,7 +81,7 @@ class TestJacLangServer(TestCase):
         self.assertIn(
             # "ability) calculate_area: float",
             "(public ability) calculate_area\n( radius : float ) -> float",
-            lsp.get_hover_info(circle_impl_file, pos).contents.value,
+            lsp.get_hover_info(circle_impl_file, pos).contents.value.replace("'", ""),
         )
 
     @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
@@ -133,12 +134,12 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         guess_game_file = uris.from_fs_path(
-            self.examples_abs_path("guess_game/guess_game4.jac")
+            self.examples_abs_path("guess_game/guess_game4.impl.jac")
         )
         lsp.deep_check(guess_game_file)
         self.assertIn(
-            "guess_game4.jac:27:8-27:21",
-            str(lsp.get_definition(guess_game_file, lspt.Position(46, 45))),
+            "guess_game4.jac:16:8-16:21",
+            str(lsp.get_definition(guess_game_file, lspt.Position(15, 45))),
         )
 
     def test_go_to_definition_method_manual_impl(self) -> None:

jaclang/langserve/utils.jac

@@ -24,10 +24,8 @@ import from jaclang.vendor.pygls { uris }
 import lsprotocol.types as lspt;
 
 
-with entry {
-    P = ParamSpec('P');
-    T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
-}
+glob P = ParamSpec('P');
+glob T = TypeVar('T', bound=Callable[(P, Coroutine[(Any, Any, Any)])]);
 
 
 """Return diagnostics."""
@@ -36,11 +34,15 @@ def gen_diagnostics(
     errors: <>list[Alert],
     warnings: <>list[Alert]
 ) -> <>list[lspt.Diagnostic] {
-    return ([ lspt.Diagnostic(range=create_range(error.loc),
-    message=error.msg,
-    severity=lspt.DiagnosticSeverity.Error) for error in errors if error.loc.mod_path == uris.to_fs_path(from_path) ] + [ lspt.Diagnostic(range=create_range(warning.loc),
-    message=warning.msg,
-    severity=lspt.DiagnosticSeverity.Warning) for warning in warnings if warning.loc.mod_path == uris.to_fs_path(from_path) ]);
+    return [ lspt.Diagnostic(
+        range=create_range(error.loc),
+        message=error.msg,
+        severity=lspt.DiagnosticSeverity.Error
+    ) for error in errors if error.loc.mod_path == uris.to_fs_path(from_path) ] + [ lspt.Diagnostic(
+        range=create_range(warning.loc),
+        message=warning.msg,
+        severity=lspt.DiagnosticSeverity.Warning
+    ) for warning in warnings if warning.loc.mod_path == uris.to_fs_path(from_path) ];
 }
 
 
@@ -156,25 +158,31 @@ def get_symbols_for_outline(<>node: UniScopeNode) -> <>list[lspt.DocumentSymbol]
             continue;
         }
         pos = create_range(item.decl.loc);
-        symbol = lspt.DocumentSymbol(name=key,
-        kind=kind_map(item.decl),
-        range=pos,
-        selection_range=pos,
-        children=[]);
+        symbol = lspt.DocumentSymbol(
+            name=key,
+            kind=kind_map(item.decl),
+            range=pos,
+            selection_range=pos,
+            children=[]
+        );
         symbols.append(symbol);
     }
     for sub_tab in [ i for i in <>node.kid_scope if i.loc.mod_path == <>node.loc.mod_path ] {
         sub_symbols = get_symbols_for_outline(sub_tab);
-        if isinstance(sub_tab,
-        (uni.IfStmt, uni.ElseStmt, uni.WhileStmt, uni.IterForStmt, uni.InForStmt)) {
+        if isinstance(
+            sub_tab,
+            (uni.IfStmt, uni.ElseStmt, uni.WhileStmt, uni.IterForStmt, uni.InForStmt)
+        ) {
             symbols.extend(sub_symbols);
         } else {
             sub_pos = create_range(sub_tab.loc);
-            symbol = lspt.DocumentSymbol(name=sub_tab.scope_name,
-            kind=kind_map(sub_tab),
-            range=sub_pos,
-            selection_range=sub_pos,
-            children=sub_symbols);
+            symbol = lspt.DocumentSymbol(
+                name=sub_tab.scope_name,
+                kind=kind_map(sub_tab),
+                range=sub_pos,
+                selection_range=sub_pos,
+                children=sub_symbols
+            );
             symbols.append(symbol);
         }
     }
@@ -193,10 +201,16 @@ def owner_sym(table: UniScopeNode) -> Optional[Symbol] {
 
 """Create an lspt.Range from a location object."""
 def create_range(loc: CodeLocInfo) -> lspt.Range {
-    return lspt.Range(start=lspt.Position(line=(loc.first_line - 1) if loc.first_line > 0 else 0 ,
-    character=(loc.col_start - 1) if loc.col_start > 0 else 0 ),
-    end=lspt.Position(line=(loc.last_line - 1) if loc.last_line > 0 else 0 ,
-    character=(loc.col_end - 1) if loc.col_end > 0 else 0 ));
+    return lspt.Range(
+        start=lspt.Position(
+            line=(loc.first_line - 1) if loc.first_line > 0 else 0 ,
+            character=(loc.col_start - 1) if loc.col_start > 0 else 0
+        ),
+        end=lspt.Position(
+            line=(loc.last_line - 1) if loc.last_line > 0 else 0 ,
+            character=(loc.col_end - 1) if loc.col_end > 0 else 0
+        )
+    );
 }
 
 
@@ -263,8 +277,9 @@ def collect_all_symbols_in_scope(
         visited.add(current_tab);
         for (name, symbol) in current_tab.names_in_scope.items() {
             if name not in dir(builtins) and symbol.sym_type != SymbolType.IMPL  {
-                symbols.append(lspt.CompletionItem(label=name,
-                kind=label_map(symbol.sym_type)));
+                symbols.append(
+                    lspt.CompletionItem(label=name, kind=label_map(symbol.sym_type))
+                );
             }
         }
         if not up_tree {
@@ -284,8 +299,12 @@ def collect_child_tabs(sym_tab: UniScopeNode) -> <>list[lspt.CompletionItem] {
     symbols : <>list[lspt.CompletionItem] = [];
     for tab in sym_tab.kid_scope {
         if tab.scope_name not in [ i.label for i in symbols ] {
-            symbols.append(lspt.CompletionItem(label=tab.scope_name,
-            kind=label_map(tab.get_type())));
+            symbols.append(
+                lspt.CompletionItem(
+                    label=tab.scope_name,
+                    kind=label_map(tab.get_type())
+                )
+            );
         }
     }
     return symbols;
@@ -368,7 +387,9 @@ def find_surrounding_tokens(
     prev_token_index = None;
     next_token_index = None;
     inside_tok = False;
-    for (i, tok) in enumerate([ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ][ 0 : ]) {
+    for (i, tok) in enumerate(
+        [ get_token_start(i, sem_tokens) for i in range(0, len(sem_tokens), 5) ][ 0 : ]
+    ) {
         if (not (prev_token_index is None or next_token_index is None ))
         and (tok[0] > change_end_line
         or (tok[0] == change_end_line and tok[1] > change_end_char )

jaclang/runtimelib/archetype.py

@@ -2,21 +2,24 @@
 
 from __future__ import annotations
 
-import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
 from functools import cached_property
+from inspect import _empty, signature
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
-from typing import Any, Callable, ClassVar, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Optional, TypeAlias, TypeVar
 from uuid import UUID, uuid4
 
+from ..compiler.constant import EdgeDir
+
 
 logger = getLogger(__name__)
 
 TARCH = TypeVar("TARCH", bound="Archetype")
 TANCH = TypeVar("TANCH", bound="Anchor")
+T = TypeVar("T")
 
 
 class AccessLevel(IntEnum):
@@ -66,6 +69,125 @@ class AnchorReport:
     context: dict[str, Any]
 
 
+DataSpatialFilter: TypeAlias = (
+    Callable[["Archetype"], bool] | "Archetype" | list["Archetype"] | None
+)
+
+
+@dataclass(eq=False, repr=False)
+class DataSpatialDestination:
+    """Object-Spatial Destination."""
+
+    direction: EdgeDir
+    edge: Callable[["Archetype"], bool] | None = None
+    node: Callable[["Archetype"], bool] | None = None
+
+    def edge_filter(self, arch: Archetype) -> bool:
+        """Filter edge."""
+        return not self.edge or self.edge(arch)
+
+    def node_filter(self, arch: Archetype) -> bool:
+        """Filter node."""
+        return not self.node or self.node(arch)
+
+
+@dataclass(eq=False, repr=False)
+class DataSpatialPath:
+    """Object-Spatial Path."""
+
+    origin: list[NodeArchetype]
+    destinations: list[DataSpatialDestination]
+    edge_only: bool
+    from_visit: bool
+
+    def __init__(
+        self,
+        origin: NodeArchetype | list[NodeArchetype],
+        destinations: list[DataSpatialDestination] | None = None,
+    ) -> None:
+        """Override Init."""
+        if not isinstance(origin, list):
+            origin = [origin]
+        self.origin = origin
+        self.destinations = [] if destinations is None else destinations
+        self.edge_only = False
+        self.from_visit = False
+
+    def convert(
+        self,
+        filter: DataSpatialFilter,
+    ) -> Callable[["Archetype"], bool] | None:
+        """Convert filter."""
+        if not filter:
+            return None
+        if callable(filter):
+            return filter
+        elif isinstance(filter, list):
+            return lambda i: i in filter
+        return lambda i: i == filter
+
+    def append(
+        self,
+        direction: EdgeDir,
+        edge: DataSpatialFilter,
+        node: DataSpatialFilter,
+    ) -> DataSpatialPath:
+        """Append destination."""
+        self.destinations.append(
+            DataSpatialDestination(direction, self.convert(edge), self.convert(node))
+        )
+        return self
+
+    def _out(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.OUT, edge, node)
+
+    def _in(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.IN, edge, node)
+
+    def _any(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.ANY, edge, node)
+
+    def edge(self) -> DataSpatialPath:
+        """Set edge only."""
+        self.edge_only = True
+        return self
+
+    def visit(self) -> DataSpatialPath:
+        """Set from visit."""
+        self.from_visit = True
+        return self
+
+    def repr_builder(self, repr: str, dest: DataSpatialDestination, mark: str) -> str:
+        """Repr builder."""
+        repr += mark
+        repr += f' (edge{" filter" if dest.edge else ""}) '
+        repr += mark
+        repr += f' (node{" filter" if dest.node else ""}) '
+        return repr
+
+    def __repr__(self) -> str:
+        """Override repr."""
+        repr = "nodes "
+        for dest in self.destinations:
+            match dest.direction:
+                case EdgeDir.IN:
+                    repr = self.repr_builder(repr, dest, "<<")
+                case EdgeDir.OUT:
+                    repr = self.repr_builder(repr, dest, ">>")
+                case _:
+                    repr = self.repr_builder(repr, dest, "--")
+        return repr.strip()
+
+
 @dataclass(eq=False, repr=False, kw_only=True)
 class Anchor:
     """Object Anchor."""
@@ -223,7 +345,7 @@ class WalkerAnchor(Anchor):
 
     archetype: WalkerArchetype
     path: list[NodeAnchor] = field(default_factory=list)
-    next: list[NodeAnchor] = field(default_factory=list)
+    next: list[NodeAnchor | EdgeAnchor] = field(default_factory=list)
     ignores: list[NodeAnchor] = field(default_factory=list)
     disengaged: bool = False
 
@@ -329,7 +451,7 @@ class Root(NodeArchetype):
 
 @dataclass(eq=False)
 class DataSpatialFunction:
-    """Data Spatial Function."""
+    """Object-Spatial Function."""
 
     name: str
     func: Callable[[Any, Any], Any]
@@ -337,9 +459,9 @@ class DataSpatialFunction:
     @cached_property
     def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
         """Get function parameter annotations."""
-        parameters = inspect.signature(self.func, eval_str=True).parameters
+        parameters = signature(self.func, eval_str=True).parameters
         if len(parameters) >= 2:
             second_param = list(parameters.values())[1]
             ty = second_param.annotation
-            return ty if ty != inspect._empty else None
+            return ty if ty != _empty else None
         return None

jaclang/runtimelib/builtin.py

@@ -10,10 +10,7 @@ from jaclang.runtimelib.constructs import Archetype, NodeArchetype, Root
 from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
 
-# FIXME: Retname this to something common, doing this way so this doesn't break
-# the existing code. Currently it can return the jac graph in both dot and json format.
-# So the name shuouldn't be dotgen but something more generic.
-def dotgen(
+def printgraph(
     node: Optional[NodeArchetype] = None,
     depth: int = -1,
     traverse: bool = False,
@@ -21,16 +18,17 @@ def dotgen(
     bfs: bool = True,
     edge_limit: int = 512,
     node_limit: int = 512,
-    dot_file: Optional[str] = None,
-    as_json: bool = False,
+    file: Optional[str] = None,
+    format: str = "dot",
 ) -> str:
-    """Print the dot graph."""
+    """Print the graph in different formats."""
     from jaclang.runtimelib.machine import JacMachineInterface as Jac
 
-    if as_json:
-        return _jac_graph_json()
+    fmt = format.lower()
+    if fmt == "json":
+        return _jac_graph_json(file)
 
-    return Jac.dotgen(
+    return Jac.printgraph(
         edge_type=edge_type,
         node=node or Jac.root(),
         depth=depth,
@@ -38,7 +36,8 @@ def dotgen(
         bfs=bfs,
         edge_limit=edge_limit,
         node_limit=node_limit,
-        dot_file=dot_file,
+        file=file,
+        format=fmt,
     )
 
 
@@ -52,7 +51,7 @@ def jobj(id: str) -> Archetype | None:
     return Jac.get_object(id)
 
 
-def _jac_graph_json() -> str:
+def _jac_graph_json(file: Optional[str] = None) -> str:
     """Get the graph in json string."""
     processed: list[Root | NodeArchetype] = []
     nodes: list[dict] = []
@@ -73,20 +72,24 @@ def _jac_graph_json() -> str:
         for ref in Jac.refs(end):
             if ref not in processed:
                 working_set.append((end, ref))
-    return json.dumps(
+    output = json.dumps(
         {
             "version": "1.0",
             "nodes": nodes,
             "edges": edges,
         }
     )
+    if file:
+        with open(file, "w") as f:
+            f.write(output)
+    return output
 
 
 __all__ = [
     "abstractmethod",
     "ClassVar",
     "override",
-    "dotgen",
+    "printgraph",
     "jid",
     "jobj",
 ]