jaclang 0.7.19__py3-none-any.whl → 0.7.20__py3-none-any.whl

jaclang/stubs/jaclang/langserve/utils.pyi

@@ -0,0 +1,55 @@
+import jaclang.compiler.absyntree as ast
+import lsprotocol.types as lspt
+from jaclang.compiler.codeloc import CodeLocInfo as CodeLocInfo
+from jaclang.compiler.constant import SymbolType as SymbolType
+from jaclang.compiler.passes.transform import Alert as Alert
+from jaclang.compiler.symtable import Symbol as Symbol, SymbolTable as SymbolTable
+from jaclang.vendor.pygls import uris as uris
+from typing import Any, Awaitable, Callable, Coroutine, ParamSpec, TypeVar
+
+T = TypeVar("T", bound=Callable[..., Coroutine[Any, Any, Any]])
+P = ParamSpec("P")
+
+def gen_diagnostics(
+    from_path: str, errors: list[Alert], warnings: list[Alert]
+) -> list[lspt.Diagnostic]: ...
+def debounce(wait: float) -> Callable[[T], Callable[..., Awaitable[None]]]: ...
+def sym_tab_list(sym_tab: SymbolTable, file_path: str) -> list[SymbolTable]: ...
+def find_node_by_position(
+    tokens: list[tuple[lspt.Position, int, int, ast.AstSymbolNode]],
+    line: int,
+    position: int,
+) -> ast.AstSymbolNode | None: ...
+def find_index(sem_tokens: list[int], line: int, char: int) -> int | None: ...
+def get_symbols_for_outline(node: SymbolTable) -> list[lspt.DocumentSymbol]: ...
+def owner_sym(table: SymbolTable) -> Symbol | None: ...
+def create_range(loc: CodeLocInfo) -> lspt.Range: ...
+def kind_map(sub_tab: ast.AstNode) -> lspt.SymbolKind: ...
+def label_map(sub_tab: SymbolType) -> lspt.CompletionItemKind: ...
+def get_mod_path(mod_path: ast.ModulePath, name_node: ast.Name) -> str | None: ...
+def get_item_path(mod_item: ast.ModuleItem) -> tuple[str, tuple[int, int]] | None: ...
+def get_definition_range(
+    filename: str, name: str
+) -> tuple[str, tuple[int, int]] | None: ...
+def collect_all_symbols_in_scope(
+    sym_tab: SymbolTable, up_tree: bool = True
+) -> list[lspt.CompletionItem]: ...
+def parse_symbol_path(text: str, dot_position: int) -> list[str]: ...
+def resolve_symbol_path(sym_name: str, node_tab: SymbolTable) -> str: ...
+def find_symbol_table(path: str, current_tab: SymbolTable | None) -> SymbolTable: ...
+def resolve_completion_symbol_table(
+    mod_tab: SymbolTable,
+    current_symbol_path: list[str],
+    current_tab: SymbolTable | None,
+) -> list[lspt.CompletionItem]: ...
+def get_token_start(
+    token_index: int | None, sem_tokens: list[int]
+) -> tuple[int, int, int]: ...
+def find_surrounding_tokens(
+    change_start_line: int,
+    change_start_char: int,
+    change_end_line: int,
+    change_end_char: int,
+    sem_tokens: list[int],
+) -> tuple[int | None, int | None, bool]: ...
+def get_line_of_code(line_number: int, lines: list[str]) -> tuple[str, int] | None: ...

jaclang/stubs/jaclang/plugin/__init__.pyi

@@ -0,0 +1,3 @@
+from .default import Architype as Architype, DSFunc as DSFunc, hookimpl as hookimpl
+
+__all__ = ["Architype", "DSFunc", "hookimpl"]

jaclang/stubs/jaclang/plugin/builtin.pyi

@@ -0,0 +1,12 @@
+from jaclang.runtimelib.constructs import NodeArchitype as NodeArchitype
+
+def dotgen(
+    node: NodeArchitype | None = None,
+    depth: int | None = None,
+    traverse: bool | None = None,
+    edge_type: list[str] | None = None,
+    bfs: bool | None = None,
+    edge_limit: int | None = None,
+    node_limit: int | None = None,
+    dot_file: str | None = None,
+) -> str: ...

jaclang/stubs/jaclang/plugin/default.pyi

@@ -0,0 +1,202 @@
+import types
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import Module
+from jaclang.compiler.constant import EdgeDir
+from jaclang.plugin.spec import P, T as T
+from jaclang.runtimelib.constructs import (
+    Anchor as Anchor,
+    Architype as Architype,
+    DSFunc as DSFunc,
+    EdgeAnchor as EdgeAnchor,
+    EdgeArchitype as EdgeArchitype,
+    ExecutionContext,
+    GenericEdge as GenericEdge,
+    JacTestCheck as JacTestCheck,
+    Memory,
+    NodeAnchor as NodeAnchor,
+    NodeArchitype as NodeArchitype,
+    Root as Root,
+    WalkerAnchor as WalkerAnchor,
+    WalkerArchitype as WalkerArchitype,
+)
+from typing import Any, Callable
+
+__all__ = [
+    "EdgeAnchor",
+    "GenericEdge",
+    "hookimpl",
+    "JacTestCheck",
+    "NodeAnchor",
+    "Anchor",
+    "WalkerAnchor",
+    "NodeArchitype",
+    "EdgeArchitype",
+    "Root",
+    "WalkerArchitype",
+    "Architype",
+    "DSFunc",
+    "T",
+]
+
+hookimpl: Incomplete
+
+class JacFeatureDefaults:
+    pm: Incomplete
+    @staticmethod
+    def context(session: str = "") -> ExecutionContext: ...
+    @staticmethod
+    def reset_context() -> None: ...
+    @staticmethod
+    def memory_hook() -> Memory | None: ...
+    @staticmethod
+    def make_architype(
+        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> type[Architype]: ...
+    @staticmethod
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def impl_patch_filename(
+        file_loc: str,
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+    @staticmethod
+    def jac_import(
+        target: str,
+        base_path: str,
+        absorb: bool,
+        cachable: bool,
+        mdl_alias: str | None,
+        override_name: str | None,
+        mod_bundle: Module | str | None,
+        lng: str | None,
+        items: dict[str, str | str | None] | None,
+    ) -> tuple[types.ModuleType, ...]: ...
+    @staticmethod
+    def create_test(test_fun: Callable) -> Callable: ...
+    @staticmethod
+    def run_test(
+        filepath: str,
+        filter: str | None,
+        xit: bool,
+        maxfail: int | None,
+        directory: str | None,
+        verbose: bool,
+    ) -> int: ...
+    @staticmethod
+    def elvis(op1: T | None, op2: T) -> T: ...
+    @staticmethod
+    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
+    @staticmethod
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
+    @staticmethod
+    def report(expr: Any) -> Any: ...
+    @staticmethod
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def disengage(walker: WalkerArchitype) -> bool: ...
+    @staticmethod
+    def edge_ref(
+        node_obj: NodeArchitype | list[NodeArchitype],
+        target_obj: NodeArchitype | list[NodeArchitype] | None,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        edges_only: bool,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def connect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        edge_spec: Callable[[], EdgeArchitype],
+        edges_only: bool,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def disconnect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+    ) -> bool: ...
+    @staticmethod
+    def assign_compr(
+        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
+    ) -> list[T]: ...
+    @staticmethod
+    def get_root() -> Root: ...
+    @staticmethod
+    def get_root_type() -> type[Root]: ...
+    @staticmethod
+    def build_edge(
+        is_undirected: bool,
+        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
+        conn_assign: tuple[tuple, tuple] | None,
+    ) -> Callable[[], EdgeArchitype]: ...
+    @staticmethod
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> str | None: ...
+    @staticmethod
+    def obj_scope(file_loc: str, attr: str) -> str: ...
+    @staticmethod
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
+    @staticmethod
+    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,
+    ) -> Any: ...
+
+class JacBuiltin:
+    @staticmethod
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: list[str],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: str | None,
+    ) -> str: ...
+
+class JacCmdDefaults:
+    @staticmethod
+    def create_cmd() -> None: ...

jaclang/stubs/jaclang/plugin/feature.pyi

@@ -0,0 +1,176 @@
+import types
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import Module as Module
+from jaclang.plugin.default import ExecutionContext as ExecutionContext
+from jaclang.plugin.spec import (
+    JacBuiltin as JacBuiltin,
+    JacCmdSpec as JacCmdSpec,
+    JacFeatureSpec as JacFeatureSpec,
+    P as P,
+    T as T,
+)
+from jaclang.runtimelib.constructs import (
+    Architype as Architype,
+    EdgeArchitype as EdgeArchitype,
+    Memory as Memory,
+    NodeArchitype as NodeArchitype,
+    Root as Root,
+    WalkerArchitype as WalkerArchitype,
+)
+from typing import Any, Callable, TypeAlias
+
+pm: Incomplete
+
+class JacFeature:
+    EdgeDir: TypeAlias
+    DSFunc: TypeAlias
+    RootType: TypeAlias
+    Obj: TypeAlias
+    Node: TypeAlias
+    Edge: TypeAlias
+    Walker: TypeAlias
+    @staticmethod
+    def context(session: str = "") -> ExecutionContext: ...
+    @staticmethod
+    def reset_context() -> None: ...
+    @staticmethod
+    def memory_hook() -> Memory | None: ...
+    @staticmethod
+    def make_architype(
+        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> type[Architype]: ...
+    @staticmethod
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def impl_patch_filename(
+        file_loc: str,
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+    @staticmethod
+    def jac_import(
+        target: str,
+        base_path: str,
+        absorb: bool = False,
+        cachable: bool = True,
+        mdl_alias: str | None = None,
+        override_name: str | None = None,
+        mod_bundle: Module | str | None = None,
+        lng: str | None = "jac",
+        items: dict[str, str | str | None] | None = None,
+    ) -> tuple[types.ModuleType, ...]: ...
+    @staticmethod
+    def create_test(test_fun: Callable) -> Callable: ...
+    @staticmethod
+    def run_test(
+        filepath: str,
+        filter: str | None = None,
+        xit: bool = False,
+        maxfail: int | None = None,
+        directory: str | None = None,
+        verbose: bool = False,
+    ) -> int: ...
+    @staticmethod
+    def elvis(op1: T | None, op2: T) -> T: ...
+    @staticmethod
+    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
+    @staticmethod
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
+    @staticmethod
+    def report(expr: Any) -> Any: ...
+    @staticmethod
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def disengage(walker: WalkerArchitype) -> bool: ...
+    @staticmethod
+    def edge_ref(
+        node_obj: NodeArchitype | list[NodeArchitype],
+        target_obj: NodeArchitype | list[NodeArchitype] | None,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        edges_only: bool = False,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def connect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        edge_spec: Callable[[], EdgeArchitype],
+        edges_only: bool = False,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def disconnect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+    ) -> bool: ...
+    @staticmethod
+    def assign_compr(
+        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
+    ) -> list[T]: ...
+    @staticmethod
+    def get_root() -> Root: ...
+    @staticmethod
+    def get_root_type() -> type[Root]: ...
+    @staticmethod
+    def build_edge(
+        is_undirected: bool,
+        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
+        conn_assign: tuple[tuple, tuple] | None,
+    ) -> Callable[[], EdgeArchitype]: ...
+    @staticmethod
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> str | None: ...
+    @staticmethod
+    def obj_scope(file_loc: str, attr: str) -> str: ...
+    @staticmethod
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
+    @staticmethod
+    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,
+    ) -> Any: ...
+
+class JacCmd:
+    @staticmethod
+    def create_cmd() -> None: ...

jaclang/stubs/jaclang/plugin/spec.pyi

@@ -0,0 +1,181 @@
+import types
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import Module as Module
+from jaclang.plugin.default import (
+    Architype as Architype,
+    DSFunc as DSFunc,
+    EdgeDir as EdgeDir,
+    ExecutionContext as ExecutionContext,
+    Root as Root,
+    WalkerArchitype as WalkerArchitype,
+)
+from jaclang.runtimelib.constructs import (
+    EdgeArchitype as EdgeArchitype,
+    NodeArchitype as NodeArchitype,
+)
+from jaclang.runtimelib.memory import Memory as Memory
+from typing import Any, Callable, ParamSpec, TypeVar
+
+hookspec: Incomplete
+T = TypeVar("T")
+P = ParamSpec("P")
+
+class JacFeatureSpec:
+    @staticmethod
+    def context(session: str = "") -> ExecutionContext: ...
+    @staticmethod
+    def reset_context() -> None: ...
+    @staticmethod
+    def memory_hook() -> Memory | None: ...
+    @staticmethod
+    def make_architype(
+        cls, arch_base: type[Architype], on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> type[Architype]: ...
+    @staticmethod
+    def make_obj(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_node(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_edge(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def make_walker(
+        on_entry: list[DSFunc], on_exit: list[DSFunc]
+    ) -> Callable[[type], type]: ...
+    @staticmethod
+    def impl_patch_filename(
+        file_loc: str,
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
+    @staticmethod
+    def jac_import(
+        target: str,
+        base_path: str,
+        absorb: bool,
+        cachable: bool,
+        mdl_alias: str | None,
+        override_name: str | None,
+        mod_bundle: Module | str | None,
+        lng: str | None,
+        items: dict[str, str | str | None] | None,
+    ) -> tuple[types.ModuleType, ...]: ...
+    @staticmethod
+    def create_test(test_fun: Callable) -> Callable: ...
+    @staticmethod
+    def run_test(
+        filepath: str,
+        filter: str | None,
+        xit: bool,
+        maxfail: int | None,
+        directory: str | None,
+        verbose: bool,
+    ) -> int: ...
+    @staticmethod
+    def elvis(op1: T | None, op2: T) -> T: ...
+    @staticmethod
+    def has_instance_default(gen_func: Callable[[], T]) -> T: ...
+    @staticmethod
+    def spawn_call(op1: Architype, op2: Architype) -> WalkerArchitype: ...
+    @staticmethod
+    def report(expr: Any) -> Any: ...
+    @staticmethod
+    def ignore(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def visit_node(
+        walker: WalkerArchitype,
+        expr: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    @staticmethod
+    def disengage(walker: WalkerArchitype) -> bool: ...
+    @staticmethod
+    def edge_ref(
+        node_obj: NodeArchitype | list[NodeArchitype],
+        target_obj: NodeArchitype | list[NodeArchitype] | None,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        edges_only: bool,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def connect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        edge_spec: Callable[[], EdgeArchitype],
+        edges_only: bool,
+    ) -> list[NodeArchitype] | list[EdgeArchitype]: ...
+    @staticmethod
+    def disconnect(
+        left: NodeArchitype | list[NodeArchitype],
+        right: NodeArchitype | list[NodeArchitype],
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+    ) -> bool: ...
+    @staticmethod
+    def assign_compr(
+        target: list[T], attr_val: tuple[tuple[str], tuple[Any]]
+    ) -> list[T]: ...
+    @staticmethod
+    def get_root() -> Root: ...
+    @staticmethod
+    def get_root_type() -> type[Root]: ...
+    @staticmethod
+    def build_edge(
+        is_undirected: bool,
+        conn_type: type[EdgeArchitype] | EdgeArchitype | None,
+        conn_assign: tuple[tuple, tuple] | None,
+    ) -> Callable[[], EdgeArchitype]: ...
+    @staticmethod
+    def get_semstr_type(
+        file_loc: str, scope: str, attr: str, return_semstr: bool
+    ) -> str | None: ...
+    @staticmethod
+    def obj_scope(file_loc: str, attr: str) -> str: ...
+    @staticmethod
+    def get_sem_type(file_loc: str, attr: str) -> tuple[str | None, str | None]: ...
+    @staticmethod
+    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,
+    ) -> Any: ...
+
+class JacBuiltin:
+    @staticmethod
+    def dotgen(
+        node: NodeArchitype,
+        depth: int,
+        traverse: bool,
+        edge_type: list[str],
+        bfs: bool,
+        edge_limit: int,
+        node_limit: int,
+        dot_file: str | None,
+    ) -> str: ...
+
+class JacCmdSpec:
+    @staticmethod
+    def create_cmd() -> None: ...