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

jaclang/stubs/jaclang/runtimelib/architype.pyi

@@ -0,0 +1,133 @@
+import types
+from dataclasses import dataclass
+from jaclang.compiler.constant import EdgeDir as EdgeDir
+from jaclang.runtimelib.utils import (
+    collect_node_connections as collect_node_connections,
+)
+from typing import Any, Callable
+from uuid import UUID
+
+@dataclass(eq=False)
+class Anchor:
+    def spawn_call(self, walk: WalkerArchitype) -> WalkerArchitype: ...
+    def __init__(self, obj, id=...) -> None: ...
+
+@dataclass(eq=False)
+class NodeAnchor(Anchor):
+    obj: NodeArchitype
+    edges: list[EdgeArchitype] = ...
+    edge_ids: list[UUID] = ...
+    persistent: bool = ...
+    def populate_edges(self) -> None: ...
+    def connect_node(self, nd: NodeArchitype, edg: EdgeArchitype) -> NodeArchitype: ...
+    def get_edges(
+        self,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        target_obj: list[NodeArchitype] | None,
+    ) -> list[EdgeArchitype]: ...
+    def edges_to_nodes(
+        self,
+        dir: EdgeDir,
+        filter_func: Callable[[list[EdgeArchitype]], list[EdgeArchitype]] | None,
+        target_obj: list[NodeArchitype] | None,
+    ) -> list[NodeArchitype]: ...
+    def gen_dot(self, dot_file: str | None = None) -> str: ...
+    def __init__(
+        self, obj, id=..., edges=..., edge_ids=..., persistent=...
+    ) -> None: ...
+
+@dataclass(eq=False)
+class EdgeAnchor(Anchor):
+    obj: EdgeArchitype
+    source: NodeArchitype | None = ...
+    target: NodeArchitype | None = ...
+    source_id: UUID | None = ...
+    target_id: UUID | None = ...
+    is_undirected: bool = ...
+    persistent: bool = ...
+    def attach(
+        self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
+    ) -> EdgeAnchor: ...
+    def detach(
+        self, src: NodeArchitype, trg: NodeArchitype, is_undirected: bool = False
+    ) -> None: ...
+    def spawn_call(self, walk: WalkerArchitype) -> WalkerArchitype: ...
+    def __init__(
+        self,
+        obj,
+        id=...,
+        source=...,
+        target=...,
+        source_id=...,
+        target_id=...,
+        is_undirected=...,
+        persistent=...,
+    ) -> None: ...
+
+@dataclass(eq=False)
+class WalkerAnchor(Anchor):
+    obj: WalkerArchitype
+    path: list[Architype] = ...
+    next: list[Architype] = ...
+    ignores: list[Architype] = ...
+    disengaged: bool = ...
+    def visit_node(
+        self,
+        nds: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    def ignore_node(
+        self,
+        nds: (
+            list[NodeArchitype | EdgeArchitype]
+            | list[NodeArchitype]
+            | list[EdgeArchitype]
+            | NodeArchitype
+            | EdgeArchitype
+        ),
+    ) -> bool: ...
+    def disengage_now(self) -> None: ...
+    def spawn_call(self, nd: Architype) -> WalkerArchitype: ...
+    def __init__(
+        self, obj, id=..., path=..., next=..., ignores=..., disengaged=...
+    ) -> None: ...
+
+class Architype:
+    def __init__(self) -> None: ...
+    def __hash__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+
+class NodeArchitype(Architype):
+    def __init__(self) -> None: ...
+    def save(self) -> None: ...
+
+class EdgeArchitype(Architype):
+    persistent: bool
+    def __init__(self) -> None: ...
+    def save(self) -> None: ...
+    def populate_nodes(self) -> None: ...
+
+class WalkerArchitype(Architype):
+    def __init__(self) -> None: ...
+
+class GenericEdge(EdgeArchitype): ...
+
+class Root(NodeArchitype):
+    reachable_nodes: list[NodeArchitype]
+    connections: set[tuple[NodeArchitype, NodeArchitype, EdgeArchitype]]
+    def __init__(self) -> None: ...
+    def reset(self) -> None: ...
+
+@dataclass(eq=False)
+class DSFunc:
+    name: str
+    trigger: type | types.UnionType | tuple[type | types.UnionType, ...] | None
+    func: Callable[[Any, Any], Any] | None = ...
+    def resolve(self, cls: type) -> None: ...
+    def __init__(self, name, trigger, func=...) -> None: ...

jaclang/stubs/jaclang/runtimelib/constructs.pyi

@@ -0,0 +1,41 @@
+from .architype import (
+    Anchor as Anchor,
+    Architype as Architype,
+    DSFunc as DSFunc,
+    EdgeAnchor as EdgeAnchor,
+    EdgeArchitype as EdgeArchitype,
+    GenericEdge as GenericEdge,
+    NodeAnchor as NodeAnchor,
+    NodeArchitype as NodeArchitype,
+    Root as Root,
+    WalkerAnchor as WalkerAnchor,
+    WalkerArchitype as WalkerArchitype,
+)
+from .context import ExecutionContext as ExecutionContext, exec_context as exec_context
+from .memory import Memory as Memory, ShelveStorage as ShelveStorage
+from .test import (
+    JacTestCheck as JacTestCheck,
+    JacTestResult as JacTestResult,
+    JacTextTestRunner as JacTextTestRunner,
+)
+
+__all__ = [
+    "Anchor",
+    "NodeAnchor",
+    "EdgeAnchor",
+    "WalkerAnchor",
+    "Architype",
+    "NodeArchitype",
+    "EdgeArchitype",
+    "WalkerArchitype",
+    "GenericEdge",
+    "Root",
+    "DSFunc",
+    "Memory",
+    "ShelveStorage",
+    "ExecutionContext",
+    "exec_context",
+    "JacTestResult",
+    "JacTextTestRunner",
+    "JacTestCheck",
+]

jaclang/stubs/jaclang/runtimelib/context.pyi

@@ -0,0 +1,48 @@
+import unittest
+from .architype import Architype as Architype, Root as Root
+from .machine import JacMachine as JacMachine
+from .memory import Memory as Memory, ShelveStorage as ShelveStorage
+from _typeshed import Incomplete
+from contextvars import ContextVar
+from typing import Callable
+from uuid import UUID
+
+class ExecutionContext:
+    mem: Memory | None
+    root: Root | None
+    jac_machine: Incomplete
+    def __init__(self) -> None: ...
+    def init_memory(self, base_path: str = "", session: str = "") -> None: ...
+    def get_root(self) -> Root: ...
+    def get_obj(self, obj_id: UUID) -> Architype | None: ...
+    def save_obj(self, item: Architype, persistent: bool) -> None: ...
+    def reset(self) -> None: ...
+
+exec_context: ContextVar[ExecutionContext | None]
+
+class JacTestResult(unittest.TextTestResult):
+    failures_count: Incomplete
+    max_failures: Incomplete
+    def __init__(
+        self, stream, descriptions, verbosity: int, max_failures: int | None = None
+    ) -> None: ...
+    def addFailure(self, test, err) -> None: ...
+    shouldStop: bool
+    def stop(self) -> None: ...
+
+class JacTextTestRunner(unittest.TextTestRunner):
+    max_failures: Incomplete
+    def __init__(self, max_failures: int | None = None, **kwargs) -> None: ...
+
+class JacTestCheck:
+    test_case: Incomplete
+    test_suite: Incomplete
+    breaker: bool
+    failcount: int
+    @staticmethod
+    def reset() -> None: ...
+    @staticmethod
+    def run_test(xit: bool, maxfail: int | None, verbose: bool) -> None: ...
+    @staticmethod
+    def add_test(test_fun: Callable) -> None: ...
+    def __getattr__(self, name: str) -> object: ...

jaclang/stubs/jaclang/runtimelib/importer.pyi

@@ -0,0 +1,104 @@
+import types
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import Module as Module
+from jaclang.compiler.compile import compile_jac as compile_jac
+from jaclang.runtimelib.machine import JacMachine as JacMachine
+from jaclang.runtimelib.utils import sys_path_context as sys_path_context
+from jaclang.utils.log import logging as logging
+
+logger: Incomplete
+
+class ImportPathSpec:
+    target: Incomplete
+    base_path: Incomplete
+    absorb: Incomplete
+    cachable: Incomplete
+    mdl_alias: Incomplete
+    override_name: Incomplete
+    mod_bundle: Incomplete
+    language: Incomplete
+    items: Incomplete
+    module_name: Incomplete
+    package_path: Incomplete
+    caller_dir: Incomplete
+    full_target: Incomplete
+    def __init__(
+        self,
+        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,
+    ) -> None: ...
+    def get_caller_dir(self) -> str: ...
+
+class ImportReturn:
+    ret_mod: Incomplete
+    ret_items: Incomplete
+    importer: Incomplete
+    def __init__(
+        self,
+        ret_mod: types.ModuleType,
+        ret_items: list[types.ModuleType],
+        importer: Importer,
+    ) -> None: ...
+    def process_items(
+        self,
+        module: types.ModuleType,
+        items: dict[str, str | str | None],
+        caller_dir: str,
+        lang: str | None,
+        mod_bundle: Module | None = None,
+        cachable: bool = True,
+    ) -> None: ...
+    def load_jac_mod_as_item(
+        self,
+        module: types.ModuleType,
+        name: str,
+        jac_file_path: str,
+        mod_bundle: Module | None,
+        cachable: bool,
+        caller_dir: str,
+    ) -> types.ModuleType | None: ...
+
+class Importer:
+    jac_machine: Incomplete
+    result: Incomplete
+    def __init__(self, jac_machine: JacMachine) -> None: ...
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...
+    def update_sys(self, module: types.ModuleType, spec: ImportPathSpec) -> None: ...
+    def get_codeobj(
+        self,
+        full_target: str,
+        module_name: str,
+        mod_bundle: Module | None,
+        cachable: bool,
+        caller_dir: str,
+    ) -> types.CodeType | None: ...
+
+class PythonImporter(Importer):
+    jac_machine: Incomplete
+    def __init__(self, jac_machine: JacMachine) -> None: ...
+    result: Incomplete
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...
+
+class JacImporter(Importer):
+    jac_machine: Incomplete
+    def __init__(self, jac_machine: JacMachine) -> None: ...
+    def get_sys_mod_name(self, full_target: str) -> str: ...
+    def handle_directory(
+        self, module_name: str, full_mod_path: str, mod_bundle: Module | str | None
+    ) -> types.ModuleType: ...
+    def create_jac_py_module(
+        self,
+        mod_bundle: Module | str | None,
+        module_name: str,
+        package_path: str,
+        full_target: str,
+    ) -> types.ModuleType: ...
+    result: Incomplete
+    def run_import(self, spec: ImportPathSpec) -> ImportReturn: ...

jaclang/stubs/jaclang/runtimelib/machine.pyi

@@ -0,0 +1,6 @@
+from _typeshed import Incomplete
+
+class JacMachine:
+    base_path: Incomplete
+    base_path_dir: Incomplete
+    def __init__(self, base_path: str = "") -> None: ...

jaclang/stubs/jaclang/runtimelib/memory.pyi

@@ -0,0 +1,26 @@
+import shelve
+from .architype import Architype as Architype
+from _typeshed import Incomplete
+from uuid import UUID
+
+class Memory:
+    mem: dict[UUID, Architype]
+    save_obj_list: dict[UUID, Architype]
+    def __init__(self) -> None: ...
+    def get_obj(self, obj_id: UUID) -> Architype | None: ...
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None: ...
+    def has_obj(self, obj_id: UUID) -> bool: ...
+    def has_obj_in_store(self, obj_id: UUID) -> bool: ...
+    def save_obj(self, item: Architype, persistent: bool) -> None: ...
+    def commit(self) -> None: ...
+    def close(self) -> None: ...
+
+class ShelveStorage(Memory):
+    storage: shelve.Shelf | None
+    def __init__(self, session: str = "") -> None: ...
+    def get_obj_from_store(self, obj_id: UUID) -> Architype | None: ...
+    def has_obj_in_store(self, obj_id: UUID | str) -> bool: ...
+    def commit(self) -> None: ...
+    session: Incomplete
+    def connect(self, session: str) -> None: ...
+    def close(self) -> None: ...

jaclang/stubs/jaclang/runtimelib/utils.pyi

@@ -0,0 +1,35 @@
+import ast as ast3
+import jaclang.compiler.absyntree as ast
+from jaclang.compiler.semtable import SemScope as SemScope
+from jaclang.runtimelib.constructs import (
+    NodeAnchor as NodeAnchor,
+    NodeArchitype as NodeArchitype,
+)
+from typing import Callable, Iterator
+
+def sys_path_context(path: str) -> Iterator[None]: ...
+def collect_node_connections(
+    current_node: NodeAnchor, visited_nodes: set, connections: set
+) -> None: ...
+def traverse_graph(
+    node: NodeArchitype,
+    cur_depth: int,
+    depth: int,
+    edge_type: list[str],
+    traverse: bool,
+    connections: list,
+    node_depths: dict[NodeArchitype, int],
+    visited_nodes: list,
+    queue: list,
+    bfs: bool,
+    dfs: Callable,
+    node_limit: int,
+    edge_limit: int,
+) -> None: ...
+def get_sem_scope(node: ast.AstNode) -> SemScope: ...
+def extract_type(node: ast.AstNode) -> list[str]: ...
+def extract_params(
+    body: ast.FuncCall,
+) -> tuple[
+    dict[str, ast.Expr], list[tuple[str, ast3.AST]], list[tuple[str, ast3.AST]]
+]: ...

jaclang/stubs/jaclang/settings.pyi

@@ -0,0 +1,35 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+
+__all__ = ["settings"]
+
+@dataclass
+class Settings:
+    fuse_type_info_debug: bool = ...
+    filter_sym_builtins: bool = ...
+    ast_symbol_info_detailed: bool = ...
+    pass_timer: bool = ...
+    py_raise: bool = ...
+    py_raise_deep: bool = ...
+    max_line_length: int = ...
+    lsp_debug: bool = ...
+    config_file_path = ...
+    def __post_init__(self) -> None: ...
+    def load_all(self) -> None: ...
+    def load_config_file(self) -> None: ...
+    def load_env_vars(self) -> None: ...
+    def str_to_bool(self, value: str) -> bool: ...
+    def convert_type(self, value: str) -> bool | str | int: ...
+    def __init__(
+        self,
+        fuse_type_info_debug=...,
+        filter_sym_builtins=...,
+        ast_symbol_info_detailed=...,
+        pass_timer=...,
+        py_raise=...,
+        py_raise_deep=...,
+        max_line_length=...,
+        lsp_debug=...,
+    ) -> None: ...
+
+settings: Incomplete

jaclang/stubs/jaclang/utils/helpers.pyi

@@ -0,0 +1,18 @@
+import pdb
+from _typeshed import Incomplete
+
+def pascal_to_snake(pascal_string: str) -> str: ...
+def heading_to_snake(heading: str) -> str: ...
+def add_line_numbers(s: str) -> str: ...
+def clip_code_section(s: str, target_line: int, line_range: int) -> str: ...
+def get_ast_nodes_as_snake_case() -> list[str]: ...
+def extract_headings(file_path: str) -> dict[str, tuple[int, int]]: ...
+def auto_generate_refs() -> None: ...
+def is_standard_lib_module(module_path: str) -> bool: ...
+
+class Jdb(pdb.Pdb):
+    prompt: str
+    def __init__(self, *args, **kwargs) -> None: ...
+    def has_breakpoint(self, bytecode: bytes) -> bool: ...
+
+debugger: Incomplete

jaclang/stubs/jaclang/utils/lang_tools.pyi

@@ -0,0 +1,43 @@
+import jaclang.compiler.absyntree as ast
+from _typeshed import Incomplete
+from jaclang.compiler.compile import jac_file_to_pass as jac_file_to_pass
+from jaclang.compiler.passes.main.pyast_load_pass import (
+    PyastBuildPass as PyastBuildPass,
+)
+from jaclang.compiler.passes.main.schedules import (
+    py_code_gen as py_code_gen,
+    py_code_gen_typed as py_code_gen_typed,
+    type_checker_sched as type_checker_sched,
+)
+from jaclang.compiler.symtable import SymbolTable as SymbolTable
+from jaclang.utils.helpers import (
+    auto_generate_refs as auto_generate_refs,
+    pascal_to_snake as pascal_to_snake,
+)
+
+class AstKidInfo:
+    name: Incomplete
+    typ: Incomplete
+    default: Incomplete
+    def __init__(self, name: str, typ: str, default: str | None = None) -> None: ...
+
+class AstNodeInfo:
+    type_map: dict[str, type]
+    cls: Incomplete
+    def __init__(self, cls: type) -> None: ...
+    name: Incomplete
+    doc: Incomplete
+    class_name_snake: Incomplete
+    init_sig: Incomplete
+    kids: Incomplete
+    def process(self, cls: type[ast.AstNode]) -> None: ...
+
+class AstTool:
+    ast_classes: Incomplete
+    def __init__(self) -> None: ...
+    def pass_template(self) -> str: ...
+    def py_ast_nodes(self) -> str: ...
+    def md_doc(self) -> str: ...
+    def ir(self, args: list[str]) -> str: ...
+    def automate_ref(self) -> str: ...
+    def gen_parser(self) -> str: ...

jaclang/stubs/jaclang/utils/log.pyi

@@ -0,0 +1,3 @@
+import logging as logging
+
+__all__ = ["logging"]

jaclang/stubs/jaclang/utils/treeprinter.pyi

@@ -0,0 +1,47 @@
+import ast as ast3
+from _typeshed import Incomplete
+from jaclang.compiler.absyntree import AstNode as AstNode, SymbolTable as SymbolTable
+from jaclang.settings import settings as settings
+
+id_bag: dict
+id_used: int
+CLASS_COLOR_MAP: dict[str, str]
+
+def dotgen_ast_tree(root: AstNode, dot_lines: list[str] | None = None) -> str: ...
+def print_ast_tree(
+    root: AstNode | ast3.AST,
+    marker: str = "+-- ",
+    level_markers: list[bool] | None = None,
+    output_file: str | None = None,
+    max_depth: int | None = None,
+) -> str: ...
+
+class SymbolTree:
+    kid: Incomplete
+    name: Incomplete
+    def __init__(
+        self,
+        node_name: str,
+        parent: SymbolTree | None = None,
+        children: list[SymbolTree] | None = None,
+    ) -> None: ...
+    @property
+    def parent(self) -> SymbolTree | None: ...
+    @parent.setter
+    def parent(self, parent_node: SymbolTree | None) -> None: ...
+
+def print_symtab_tree(
+    root: SymbolTable,
+    marker: str = "+-- ",
+    level_markers: list[bool] | None = None,
+    output_file: str | None = None,
+    depth: int | None = None,
+) -> str: ...
+def get_symtab_tree_str(
+    root: SymbolTree,
+    marker: str = "+-- ",
+    level_markers: list[bool] | None = None,
+    output_file: str | None = None,
+    depth: int | None = None,
+) -> str: ...
+def dotgen_symtab_tree(node: SymbolTable) -> str: ...

jaclang/tests/fixtures/builtins_test.jac

@@ -0,0 +1,16 @@
+with entry {
+    a: list[str] = [];
+    a.append("str1");
+    a.append("str2");
+    a.pop();
+    a.pop();
+
+    str(6).count("6");
+    int("5");
+
+    b: dict[str, list[int]] = {"a": [2, 3, 4]};
+    b.keys();
+    b["a"].append(9);
+
+    dir(a);
+}

jaclang/tests/fixtures/match_multi_ex.jac

@@ -0,0 +1,12 @@
+with entry{
+    Num =10;
+    match Num{
+        case 2:
+            print("Two");
+        case 10:
+            print("Ten");
+            print("ten");
+        case _:
+            print("nothing");
+    }
+}

jaclang/tests/test_cli.py

@@ -190,6 +190,33 @@ class JacCliTests(TestCase):
             r"8\:37 \- 8:44.*ModuleItem - display - abs_path\:.*fixtures/pygame_mock/display.py",
         )
 
+    def test_builtins_loading(self) -> None:
+        """Testing for print AstTool."""
+        from jaclang.settings import settings
+
+        settings.ast_symbol_info_detailed = True
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('builtins_test.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        settings.ast_symbol_info_detailed = False
+
+        self.assertRegex(
+            stdout_value,
+            r"2\:8 \- 2\:12.*BuiltinType - list - .*SymbolPath: builtins_test.builtins.list",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"15\:5 \- 15\:8.*Name - dir - .*SymbolPath: builtins_test.builtins.dir",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"13\:12 \- 13\:18.*Name - append - .*SymbolPath: builtins_test.builtins.list.append",
+        )
+
     def test_ast_dotgen(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -218,8 +245,8 @@ class JacCliTests(TestCase):
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
         self.assertEqual(stdout_value.count("type_info.ServerWrapper"), 7)
-        self.assertEqual(stdout_value.count("builtins.int"), 2)
-        self.assertEqual(stdout_value.count("builtins.str"), 7)
+        self.assertEqual(stdout_value.count("builtins.int"), 3)
+        self.assertEqual(stdout_value.count("builtins.str"), 10)
 
     def test_build_and_run(self) -> None:
         """Testing for print AstTool."""

jaclang/tests/test_language.py

@@ -1020,3 +1020,13 @@ class JacLanguageTests(TestCase):
         self.assertEqual(len(stdout_value[0]), 32)
         self.assertEqual("MyNode(value=0)", stdout_value[1])
         self.assertEqual("valid: True", stdout_value[2])
+
+    def test_match_multi_ex(self) -> None:
+        """Test match case with multiple expressions."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        jac_import("match_multi_ex", base_path=self.fixture_abs_path("./"))
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue().split("\n")
+        self.assertEqual("Ten", stdout_value[0])
+        self.assertEqual("ten", stdout_value[1])

jaclang/utils/treeprinter.py

@@ -113,7 +113,7 @@ def print_ast_tree(
                     if node.sym
                     else "<No Symbol is associated with this node>"
                 )
-                out += f" SymbolPath: {symbol}"
+                out += f", SymbolPath: {symbol}"
             return out
         elif isinstance(node, Token):
             return f"{node.__class__.__name__} - {node.value}, {access}"

{jaclang-0.7.19.dist-info → jaclang-0.7.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.19
+Version: 0.7.20
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 Home-page: https://jaseci.org
 License: MIT