jaclang 0.8.9__py3-none-any.whl → 0.8.10__py3-none-any.whl

jaclang/tests/test_reference.py

@@ -3,6 +3,7 @@
 import io
 import os
 from contextlib import redirect_stdout
+import sys
 from typing import Callable, Optional
 
 import jaclang
@@ -65,6 +66,12 @@ class JacReferenceTests(TestCase):
                 )
             return f.getvalue()
 
+        def normalize_function_addresses(text: str) -> str:
+            """Normalize function memory addresses in output for consistent comparison."""
+            import re
+            # Replace <function Name at 0xADDRESS> with <function Name at 0x...>
+            return re.sub(r'<function (\w+) at 0x[0-9a-f]+>', r'<function \1 at 0x...>', text)
+
         try:
             if "tests.jac" in filename or "check_statements.jac" in filename:
                 return
@@ -76,13 +83,21 @@ class JacReferenceTests(TestCase):
             )
             output_jac = execute_and_capture_output(code_content, filename=filename)
             Jac.reset_machine()
+            # Clear byllm modules from cache to ensure consistent behavior between JAC and Python runs
+            # when byllm is used
+            sys.modules.pop("byllm", None)
+            sys.modules.pop("byllm.lib", None)
             filename = filename.replace(".jac", ".py")
             with open(filename, "r") as file:
                 code_content = file.read()
             output_py = execute_and_capture_output(code_content, filename=filename)
 
-            # print(f"\nJAC Output:\n{output_jac}")
-            # print(f"\nPython Output:\n{output_py}")
+            # Normalize function addresses before comparison
+            output_jac = normalize_function_addresses(output_jac)
+            output_py = normalize_function_addresses(output_py)
+
+            print(f"\nJAC Output:\n{output_jac}")
+            print(f"\nPython Output:\n{output_py}")
 
             self.assertGreater(len(output_py), 0)
             # doing like below for concurrent_expressions.jac and other current tests

jaclang/utils/NonGPT.py

@@ -0,0 +1,375 @@
+# type: ignore
+# flake8: noqa
+from __future__ import annotations
+import inspect
+import random
+import string
+import sys
+import types
+from collections import deque
+from dataclasses import is_dataclass, fields as dc_fields, MISSING
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from functools import wraps
+from typing import (
+    Any,
+    Annotated,
+    Callable,
+    Literal,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+    TypeVar,
+    NewType,
+)
+from uuid import UUID, uuid4
+
+# -------------------------------
+# Core: random value generator
+# -------------------------------
+
+_RAND_STR_ALPH = string.ascii_letters + string.digits
+
+
+def _rand_str(n: int = 12) -> str:
+    return "".join(random.choice(_RAND_STR_ALPH) for _ in range(n))
+
+
+def _is_typed_dict(tp: Any) -> bool:
+    # TypedDict subclasses have these markers in CPython
+    return (
+        isinstance(tp, type)
+        and hasattr(tp, "__annotations__")
+        and hasattr(tp, "__required_keys__")
+    )
+
+
+def _is_namedtuple(tp: Any) -> bool:
+    return (
+        isinstance(tp, type)
+        and issubclass(tp, tuple)
+        and hasattr(tp, "_fields")
+        and hasattr(tp, "__annotations__")
+    )
+
+
+def _is_enum(tp: Any) -> bool:
+    try:
+        import enum
+
+        return isinstance(tp, type) and issubclass(tp, enum.Enum)
+    except Exception:
+        return False
+
+
+def _safe_subclasses(tp: Any) -> list[type]:
+    try:
+        return list(tp.__subclasses__())  # pragma: no cover
+    except Exception:
+        return []
+
+
+def _unwrap_annotated(tp: Any) -> Any:
+    if get_origin(tp) is Annotated:
+        return get_args(tp)[0]
+    return tp
+
+
+def _unwrap_newtype(tp: Any) -> Any:
+    # NewType returns a function that has __supertype__ attr
+    if hasattr(tp, "__supertype__"):
+        return tp.__supertype__
+    return tp
+
+
+def _choose_from(seq):
+    return random.choice(list(seq))
+
+
+def _random_primitive(tp):
+    if tp is int:
+        return random.randint(-(10**6), 10**6)
+    if tp is float:
+        # Avoid NaN/inf to keep it JSON-safe & well-behaved
+        return random.uniform(-(10**6), 10**6)
+    if tp is bool:
+        return bool(random.getrandbits(1))
+    if tp is str:
+        return _rand_str()
+    if tp is bytes:
+        return _rand_str().encode()
+    if tp is complex:
+        return complex(random.uniform(-100, 100), random.uniform(-100, 100))
+    if tp is Decimal:
+        return Decimal(str(random.uniform(-1000, 1000)))
+    if tp is UUID:
+        return uuid4()
+    if tp is datetime:
+        return datetime.fromtimestamp(random.randint(0, 2_000_000_000))
+    if tp is date:
+        return date.fromordinal(random.randint(700_000, 800_000))
+    if tp is time:
+        return (
+            datetime.min + timedelta(seconds=random.randint(0, 24 * 3600 - 1))
+        ).time()
+    if tp is type(None):
+        return None
+    return None  # sentinel
+
+
+def random_value_for_type(tp: Any, *, _depth: int = 0, _max_depth: int = 10) -> Any:
+    """Generate a random value that (best-effort) conforms to the type 'tp'."""
+    random.seed(42)  # for reproducibility in tests
+    if _depth > _max_depth:
+        # Depth cap to avoid infinite recursion on self-referential types
+        origin = get_origin(tp)
+        if origin in (list, set, frozenset, tuple, dict, deque):
+            return origin() if origin is not tuple else tuple()
+        prim = _random_primitive(_unwrap_newtype(_unwrap_annotated(tp)))
+        if prim is not None:
+            return prim
+        return None
+
+    tp = _unwrap_newtype(_unwrap_annotated(tp))
+
+    # Any / object => pick a simple JSON-friendly value
+    if tp in (Any, object):
+        return random.choice(
+            [_rand_str(), random.randint(0, 9999), True, None, random.uniform(0, 1)]
+        )
+
+    # Primitives and common stdlib scalars
+    prim = _random_primitive(tp)
+    if prim is not None:
+        return prim
+
+    # Literal
+    if get_origin(tp) is Literal:
+        choices = get_args(tp)
+        return _choose_from(choices)
+
+    # Union / Optional
+    if get_origin(tp) is Union:
+        options = list(get_args(tp))
+        # Bias slightly away from None, if present
+        if type(None) in options and len(options) > 1 and random.random() < 0.3:
+            return None
+        chosen = (
+            _choose_from([t for t in options if t is not type(None)])
+            if options
+            else None
+        )
+        return random_value_for_type(chosen, _depth=_depth + 1, _max_depth=_max_depth)
+
+    # Tuple (fixed-length or variadic)
+    if get_origin(tp) is tuple:
+        args = get_args(tp)
+        if len(args) == 2 and args[1] is Ellipsis:
+            # Tuple[T, ...]
+            n = random.randint(0, 5)
+            return tuple(
+                random_value_for_type(args[0], _depth=_depth + 1, _max_depth=_max_depth)
+                for _ in range(n)
+            )
+        else:
+            return tuple(
+                random_value_for_type(a, _depth=_depth + 1, _max_depth=_max_depth)
+                for a in args
+            )
+
+    # List / Set / FrozenSet / Deque / Dict
+    origin = get_origin(tp)
+    if origin in (list, set, frozenset, deque):
+        (elem_type,) = get_args(tp) or (Any,)
+        size = random.randint(0, 5)
+        elems = [
+            random_value_for_type(elem_type, _depth=_depth + 1, _max_depth=_max_depth)
+            for _ in range(size)
+        ]
+        if origin is list:
+            return elems
+        if origin is set:
+            # Attempt to hash; fallback to str
+            try:
+                return set(elems)
+            except TypeError:
+                return {str(e) for e in elems}
+        if origin is frozenset:
+            try:
+                return frozenset(elems)
+            except TypeError:
+                return frozenset(str(e) for e in elems)
+        if origin is deque:
+            return deque(elems)
+
+    if origin is dict:
+        key_t, val_t = (get_args(tp) + (Any, Any))[:2]
+
+        # Try to keep keys hashable and simple
+        def mk_key():
+            k = random_value_for_type(key_t, _depth=_depth + 1, _max_depth=_max_depth)
+            try:
+                hash(k)
+                return k
+            except TypeError:
+                return str(k)
+
+        size = random.randint(0, 5)
+        return {
+            mk_key(): random_value_for_type(
+                val_t, _depth=_depth + 1, _max_depth=_max_depth
+            )
+            for _ in range(size)
+        }
+
+    # TypedDict
+    if _is_typed_dict(tp):
+        # Required and optional keys are tracked by __required_keys__/__optional_keys__
+        req = getattr(tp, "__required_keys__", set())
+        opt = getattr(tp, "__optional_keys__", set())
+        anns = tp.__annotations__
+        out = {}
+        # required
+        for k in req:
+            out[k] = random_value_for_type(
+                anns[k], _depth=_depth + 1, _max_depth=_max_depth
+            )
+        # some optional
+        for k in opt:
+            if random.random() < 0.6:
+                out[k] = random_value_for_type(
+                    anns[k], _depth=_depth + 1, _max_depth=_max_depth
+                )
+        return out
+
+    # NamedTuple
+    if _is_namedtuple(tp):
+        anns = get_type_hints(tp, include_extras=True)
+        values = [
+            random_value_for_type(anns[name], _depth=_depth + 1, _max_depth=_max_depth)
+            for name in tp._fields
+        ]
+        return tp(*values)
+
+    # Enum
+    if _is_enum(tp):
+        return _choose_from(list(tp))
+
+    # Dataclass
+    if is_dataclass(tp):
+        # Resolve string annotations to actual types
+        try:
+            type_hints = get_type_hints(tp, include_extras=True)
+        except Exception:
+            type_hints = {}
+
+        kwargs = {}
+        for f in dc_fields(tp):
+            if f.init:
+                if f.default is not MISSING or f.default_factory is not MISSING:
+                    # let default/default_factory handle it sometimes
+                    if random.random() < 0.35:
+                        continue
+                # Use resolved type hints if available, otherwise use the field type
+                field_type = type_hints.get(f.name, f.type)
+                kwargs[f.name] = random_value_for_type(
+                    field_type, _depth=_depth + 1, _max_depth=_max_depth
+                )
+        try:
+            return tp(**kwargs)
+        except TypeError:
+            # Fall back to constructing with defaults only
+            return tp(**{k: v for k, v in kwargs.items() if v is not MISSING})
+
+    # Annotated already unwrapped; NewType already unwrapped
+
+    # TypeVar: use bound or one of constraints, else Any
+    if isinstance(tp, TypeVar):
+        if tp.__constraints__:
+            chosen = _choose_from(tp.__constraints__)
+            return random_value_for_type(
+                chosen, _depth=_depth + 1, _max_depth=_max_depth
+            )
+        if tp.__bound__:
+            return random_value_for_type(
+                tp.__bound__, _depth=_depth + 1, _max_depth=_max_depth
+            )
+        return random_value_for_type(Any, _depth=_depth + 1, _max_depth=_max_depth)
+
+    # Callable[...] -> synthesize a dummy callable with compatible signature if possible
+    if get_origin(tp) is Callable:
+        # Return a lambda that returns a random value for the annotated return type (or Any)
+        args = get_args(tp)
+        ret_t = Any
+        if args:
+            # args is (arg_types, ret_type)
+            if len(args) == 2:
+                ret_t = args[1]
+
+        def _fn_stub(*_a, **_k):
+            return random_value_for_type(
+                ret_t, _depth=_depth + 1, _max_depth=_max_depth
+            )
+
+        return _fn_stub
+
+    # Plain classes:
+    # 1) If it’s a built-in container alias (like typing.List without params), treat as Any
+    if tp in (list, set, frozenset, tuple, dict, deque):
+        return random_value_for_type(Any, _depth=_depth + 1, _max_depth=_max_depth)
+
+    # 2) Try to instantiate using __init__ annotations.
+    if isinstance(tp, type):
+        try:
+            sig = inspect.signature(tp)
+            kwargs = {}
+            for name, param in sig.parameters.items():
+                if name == "self":
+                    continue
+                ann = (
+                    param.annotation if param.annotation is not inspect._empty else Any
+                )
+                if param.default is not inspect._empty and random.random() < 0.4:
+                    # sometimes rely on defaults
+                    continue
+                # if VAR_POSITIONAL/VAR_KEYWORD, skip
+                if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+                    continue
+                kwargs[name] = random_value_for_type(
+                    ann, _depth=_depth + 1, _max_depth=_max_depth
+                )
+            return tp(**kwargs)
+        except Exception:
+            try:
+                return tp()
+            except Exception:
+                # Last resort: create a simple object with random attrs
+                obj = types.SimpleNamespace()
+                return obj
+
+    # Fallback
+    return None
+
+
+# -------------------------------
+# Decorator
+# -------------------------------
+
+
+def returns_fake(func: Any):
+    """Decorator that returns a random instance of the function's return type."""
+    # Resolve forward refs and Annotated, NewType, etc.
+    try:
+        type_hints = get_type_hints(
+            func, globalns=func.__globals__, localns=None, include_extras=True
+        )
+    except Exception:
+        type_hints = getattr(func, "__annotations__", {})
+    ret_t = type_hints.get("return", Any)
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return random_value_for_type(ret_t)
+
+    return wrapper

jaclang/utils/helpers.py

@@ -156,6 +156,24 @@ def dump_traceback(e: Exception) -> str:
     def byte_offset_to_char_offset(string: str, offset: int) -> int:
         return len(string.encode("utf-8")[:offset].decode("utf-8", errors="replace"))
 
+    # Utility function to check if a file is a compiled Jac file and get the original .jac source
+    def get_jac_source_info(py_filename: str) -> tuple[str | None, str | None]:
+        """Return (jac_filename, jac_source) if available, else (None, None)."""
+        # Check if this is a generated Python file from Jac compilation
+        # Generated Python files are stored in __jac_gen__ directory
+        if "__jac_gen__" in py_filename and py_filename.endswith(".py"):
+            # Try to find the corresponding .jac file
+            # The generated .py file typically mirrors the original .jac structure
+            jac_filename = py_filename.replace("__jac_gen__", "").replace(".py", ".jac")
+            if os.path.exists(jac_filename):
+                try:
+                    with open(jac_filename, "r") as f:
+                        jac_source = f.read()
+                    return jac_filename, jac_source
+                except Exception:
+                    pass
+        return None, None
+
     tb = TracebackException(type(e), e, e.__traceback__, limit=None, compact=True)
     trace_dump += f"Error: {str(e)}\n"
 
@@ -170,6 +188,11 @@ def dump_traceback(e: Exception) -> str:
     for idx, frame in enumerate(tb.stack):
         func_signature = frame.name + ("()" if frame.name.isidentifier() else "")
 
+        # Check if we can map this to a .jac file
+        jac_filename, jac_source = get_jac_source_info(frame.filename)
+        display_filename = jac_filename if jac_filename else frame.filename
+        display_source = jac_source if jac_source else None
+
         # Pretty print the most recent call's location.
         if idx == 0 and (
             (frame.lineno is not None) and frame.line and frame.line.strip() != ""
@@ -188,22 +211,27 @@ def dump_traceback(e: Exception) -> str:
                 off_start = byte_offset_to_char_offset(line_o, frame.colno) - 1
                 off_end = byte_offset_to_char_offset(line_o, frame.end_colno) - 1
 
-                # Get the source.
-                file_source = None
-                with open(frame.filename, "r") as file:
-                    file_source = file.read()
-
-                # Get the source offset.
-                lines = file_source.split("\n")
-                for i in range(frame.lineno - 1):
-                    off_start += len(lines[i]) + 1
-                    off_end += len(lines[i]) + 1
-
-                trace_dump += pretty_print_source_location(
-                    frame.filename, file_source, frame.lineno, off_start, off_end
-                )
-
-        trace_dump += f'\n{" " * dump_tab_width}at {func_signature} {frame.filename}:{frame.lineno}'
+                # Get the source - prefer .jac source if available, otherwise use .py
+                file_source = display_source
+                if file_source is None:
+                    try:
+                        with open(frame.filename, "r") as file:
+                            file_source = file.read()
+                    except Exception:
+                        file_source = ""
+
+                if file_source:
+                    # Get the source offset.
+                    lines = file_source.split("\n")
+                    for i in range(frame.lineno - 1):
+                        off_start += len(lines[i]) + 1
+                        off_end += len(lines[i]) + 1
+
+                    trace_dump += pretty_print_source_location(
+                        display_filename, file_source, frame.lineno, off_start, off_end
+                    )
+
+        trace_dump += f'\n{" " * dump_tab_width}at {func_signature} {display_filename}:{frame.lineno}'
 
     return trace_dump
 

jaclang/utils/lang_tools.py

@@ -181,7 +181,7 @@ class AstTool:
         """Generate a AST, SymbolTable tree for .jac file, or Python AST for .py file."""
         error = (
             "Usage: ir <choose one of (sym / sym. / ast / ast. / docir / "
-            "pyast / py / unparse)> <.py or .jac file_path>"
+            "pyast / py / unparse / esast / es)> <.py or .jac file_path>"
         )
         if len(args) != 2:
             return error
@@ -263,6 +263,29 @@ class AstTool:
                         if isinstance(ir.gen.py[0], str)
                         else "Compile failed."
                     )
+                case "esast":
+                    from jaclang.compiler.passes.ecmascript import (
+                        EsastGenPass,
+                        es_node_to_dict,
+                    )
+                    import json
+
+                    esast_pass = EsastGenPass(ir, prog)
+                    es_ir = esast_pass.ir_out
+                    if hasattr(es_ir.gen, "es_ast") and es_ir.gen.es_ast:
+                        return f"\n{json.dumps(es_node_to_dict(es_ir.gen.es_ast), indent=2)}"
+                    else:
+                        return "ECMAScript AST generation failed."
+                case "es":
+                    from jaclang.compiler.passes.ecmascript import EsastGenPass
+                    from jaclang.compiler.passes.ecmascript.es_unparse import es_to_js
+
+                    esast_pass = EsastGenPass(ir, prog)
+                    es_ir = esast_pass.ir_out
+                    if hasattr(es_ir.gen, "es_ast") and es_ir.gen.es_ast:
+                        return f"\n{es_to_js(es_ir.gen.es_ast)}"
+                    else:
+                        return "ECMAScript code generation failed."
                 case _:
                     return f"Invalid key: {error}"
         else:
@@ -279,14 +302,18 @@ class AstTool:
             for kid in cls.kids:
                 if "_end" in kid.name:
                     kid.name = kid.name.replace("_end", "_end_")
-                arrow = "-.->" if "Optional" in kid.typ else "-->"
+                typ_str = str(kid.typ)
+                arrow = "-.->" if "Optional" in typ_str else "-->"
                 typ = (
-                    kid.typ.replace("Optional[", "")
+                    typ_str.replace("typing.", "")
+                    .replace("jaclang.compiler.unitree.", "")
+                    .replace("Optional[", "")
+                    .replace("Union[", "")
                     .replace("SubTag[", "")
                     .replace("Sequence[", "")
+                    .replace("list[", "list - ")
                     .replace("]", "")
                     .replace("|", ",")
-                    .replace("list[", "list - ")
                 )
                 output += f"{cls.name} {arrow}|{typ}| {kid.name}\n"
             output += "```\n\n"

jaclang/utils/tests/test_lang_tools.py

@@ -135,6 +135,6 @@ class JacAstToolTests(TestCase):
         """Testing for Autodoc for Uninodes."""
         auto_uni = self.tool.autodoc_uninode()
         self.assertIn(
-            "## LambdaExpr\n```mermaid\nflowchart LR\nLambdaExpr -->|Expr| body",
+            "## LambdaExpr\n```mermaid\nflowchart LR\nLambdaExpr -->|Expr, CodeBlockStmt| body",
             auto_uni,
         )

jaclang/utils/treeprinter.py

@@ -234,12 +234,17 @@ def print_ast_tree(
             and not print_py_raise
         ):
             return f"{node.__class__.__name__} - PythonModuleRaised: {node.name}"
-        elif isinstance(node, (uni.ModuleItem, uni.ModulePath)):
+        elif isinstance(node, uni.ModuleItem):
             out = (
-                f"{node.__class__.__name__} - {node.sym_name} - "
+                f"{node.__class__.__name__} - {node.name.sym_name} - "
+                f"abs_path: {node.abs_path}"
+            )
+            return out
+        elif isinstance(node, uni.ModulePath):
+            out = (
+                f"{node.__class__.__name__} - {'.'.join([n.value for n in node.path] if node.path else [])} - "
                 f"abs_path: {node.abs_path}"
             )
-
             return out
         elif isinstance(node, AstSymbolNode):
             out = (

{jaclang-0.8.9.dist-info → jaclang-0.8.10.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: jaclang
-Version: 0.8.9
+Version: 0.8.10
 Summary: Jac is a unique and powerful programming language that runs on top of Python, offering an unprecedented level of intelligence and intuitive understanding.
 License: MIT
 Keywords: jac,jaclang,jaseci,python,programming-language,machine-learning,artificial-intelligence
 Author: Jason Mars
-Author-email: jason@jaseci.org
+Author-email: jason@mars.ninja
 Maintainer: Jason Mars
-Maintainer-email: jason@jaseci.org
+Maintainer-email: jason@mars.ninja
 Requires-Python: >=3.11.0,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3