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

jaclang/compiler/absyntree.py

@@ -1261,6 +1261,9 @@ class Enum(ArchSpec, AstAccessNode, AstImplNeedingNode, ArchBlockStmt):
             res = res and self.semstr.normalize(deep) if self.semstr else res
             res = res and self.decorators.normalize(deep) if self.decorators else res
         new_kid: list[AstNode] = []
+        if self.decorators:
+            new_kid.append(self.gen_token(Tok.DECOR_OP))
+            new_kid.append(self.decorators)
         if self.doc:
             new_kid.append(self.doc)
         new_kid.append(self.gen_token(Tok.KW_ENUM))
@@ -4278,10 +4281,9 @@ class String(Literal):
         elif self.value.startswith(("'", '"')):
             repr_str = self.value.encode().decode("unicode_escape")
             if (
-                self.value.startswith('"""')
-                and self.value.endswith('"""')
-                and not self.find_parent_of_type(FString)
-            ):
+                (self.value.startswith('"""') and self.value.endswith('"""'))
+                or (self.value.startswith("'''") and self.value.endswith("'''"))
+            ) and not self.find_parent_of_type(FString):
                 return repr_str[3:-3]
             if (not self.find_parent_of_type(FString)) or (
                 not (

jaclang/compiler/parser.py

@@ -706,10 +706,12 @@ class JacParser(Pass):
                     | NAME (COLON STRING)?
                     | py_code_block
                     | free_code
+                    | abstract_ability
+                    | ability
             """
-            if isinstance(kid[0], ast.PyInlineCode):
+            if isinstance(kid[0], (ast.PyInlineCode, ast.Ability)):
                 return self.nu(kid[0])
-            if isinstance(kid[0], (ast.Name)):
+            elif isinstance(kid[0], (ast.Name)):
                 if (
                     len(kid) >= 3
                     and isinstance(kid[-1], ast.Expr)

jaclang/compiler/passes/main/tests/fixtures/fstrings.jac

@@ -42,6 +42,8 @@ with entry {
         len(f_s1), len(f_s2)
     ) ;
     """sdfsdf\nsdfsdfsdfsd dffgdfgd.""" ;
+    c1 = '''hello klkl"""''';
+    print(c1) ;
 }
 can func() {;
 }

jaclang/plugin/default.py

@@ -510,9 +510,10 @@ class JacBuiltinImpl:
             'fillcolor="invis", fontcolor="black"];\n'
         )
         for source, target, edge in connections:
+            edge_label = html.escape(str(edge.__jac__.architype))
             dot_content += (
                 f"{visited_nodes.index(source)} -> {visited_nodes.index(target)} "
-                f' [label="{html.escape(str(edge.__jac__.architype))} "];\n'
+                f' [label="{edge_label if "GenericEdge" not in edge_label else ""}"];\n'
             )
         for node_ in visited_nodes:
             color = (
@@ -854,8 +855,13 @@ class JacFeatureImpl(
 
     @staticmethod
     @hookimpl
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
+        ctx = Jac.get_context()
+        if custom:
+            ctx.custom = expr
+        else:
+            ctx.reports.append(expr)
 
     @staticmethod
     @hookimpl

jaclang/plugin/feature.py

@@ -371,9 +371,9 @@ class JacFeature(
         return plugin_manager.hook.has_instance_default(gen_func=gen_func)
 
     @staticmethod
-    def report(expr: Any) -> Any:  # noqa: ANN401
+    def report(expr: Any, custom: bool = False) -> None:  # noqa: ANN401
         """Jac's report stmt feature."""
-        return plugin_manager.hook.report(expr=expr)
+        plugin_manager.hook.report(expr=expr, custom=custom)
 
     @staticmethod
     def edge_ref(

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/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());
+}

jaclang/tests/test_language.py

@@ -237,6 +237,7 @@ class JacLanguageTests(TestCase):
         self.assertEqual(stdout_value.split("\n")[0], "11 13 12 12 11 12 12")
         self.assertEqual(stdout_value.split("\n")[1], '12 12 """hello"""  18 18')
         self.assertEqual(stdout_value.split("\n")[2], "11 12 11 12 11 18 23")
+        self.assertEqual(stdout_value.split("\n")[3], 'hello klkl"""')
 
     def test_deep_imports(self) -> None:
         """Parse micro jac file."""
@@ -491,7 +492,7 @@ class JacLanguageTests(TestCase):
         jac_import("enum_inside_archtype", base_path=self.fixture_abs_path("./"))
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertEqual("2\n", stdout_value)
+        self.assertIn("2 Accessing privileged Data", stdout_value)
 
     def test_needs_import_1(self) -> None:
         """Test py ast to Jac ast conversion output."""

{jaclang-0.7.23.dist-info → jaclang-0.7.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaclang
-Version: 0.7.23
+Version: 0.7.24
 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
@@ -14,6 +14,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: llm
 Provides-Extra: streamlit

{jaclang-0.7.23.dist-info → jaclang-0.7.24.dist-info}/RECORD

@@ -6,12 +6,12 @@ jaclang/cli/cli.py,sha256=42ebFJyoIIUl8Jn9CHSfm9CgM6meHYDddgk3gGoY-dQ,15969
 jaclang/cli/cmdreg.py,sha256=5mhzLJnpHfc0Z22qKQgcEOICgBaC95G9gSJZ-R7GqvU,8282
 jaclang/compiler/.gitignore,sha256=n1k2_xXTorp9PY8hhYM4psHircn-NMaFx95bSgDKopo,10
 jaclang/compiler/__init__.py,sha256=O1GO5Hb02vRlz7OpYHinQV5lQ7YuNUV9Hgjlc3QWtZg,2780
-jaclang/compiler/absyntree.py,sha256=cBF837cKo7lUDzBX_dvzCf0pCOcq4eNsHgseIjgEvXk,139002
+jaclang/compiler/absyntree.py,sha256=kFXn__PKD3uuXmgWgHb-iyjKJ3zVlOqouqxRklVVKz0,139182
 jaclang/compiler/codeloc.py,sha256=YhJcHjhMCOT6mV1qLehwriuFgW0H2-ntq68k_r8yBs4,2800
 jaclang/compiler/compile.py,sha256=0d8p4i2LXg2RCu1XfWx_Jq_dx7pK2Zn2VIj-apvX_nI,3389
 jaclang/compiler/constant.py,sha256=gKccXK4Qf3CWuv8J1oaWrwqdP7CRIf7ndayquRx6Xgs,9007
 jaclang/compiler/jac.lark,sha256=NmoNb_hE4xKgVEo9aFreE9RdGOIvCBq-NU0Qs5Js6VE,17393
-jaclang/compiler/parser.py,sha256=QAiHcqBACxrg4t0jpoRDGYJssPWRC7P9eCYsIaBDMGE,142479
+jaclang/compiler/parser.py,sha256=5plH4yEEla89sHKqd5F6bCVZCh3e4gH9o-ovnX0V69s,142565
 jaclang/compiler/passes/__init__.py,sha256=0Tw0d130ZjzA05jVcny9cf5NfLjlaM70PKqFnY4zqn4,69
 jaclang/compiler/passes/ir_pass.py,sha256=8F9YL6dUUm6gP2ZkjIuaYgX7GHwyck5MEB7LYJdAhQc,5607
 jaclang/compiler/passes/main/__init__.py,sha256=DLbOP_7q8jJ9-ME_8A0d_FVk2crh9etTmTGQmtKWLnY,973
@@ -42,7 +42,7 @@ jaclang/compiler/passes/main/tests/fixtures/blip.jac,sha256=Fx9zqQ8VkiQ6vgzbQv9L
 jaclang/compiler/passes/main/tests/fixtures/codegentext.jac,sha256=U9xyk8hDlWM3jUaozQXOD61f5p9SI-_QfDxA68DUYds,562
 jaclang/compiler/passes/main/tests/fixtures/decls.jac,sha256=vPHNZeXuFKLclAFJfe92ajOX7n0ULsvEi5jBoDU-Ns8,123
 jaclang/compiler/passes/main/tests/fixtures/defs_and_uses.jac,sha256=zTTq_0u8ITmODu8rjRloI5Imwf2dICHdiKdOnzcgpbg,901
-jaclang/compiler/passes/main/tests/fixtures/fstrings.jac,sha256=6QRZtTSuG1vIA7egTv-rY27U6HRaXeiOyuNs1sIU5Bk,1089
+jaclang/compiler/passes/main/tests/fixtures/fstrings.jac,sha256=d47PXLSX2GKekOv4mzZxmBWVRF4AGrs6rm6XA_7NCrQ,1135
 jaclang/compiler/passes/main/tests/fixtures/func.jac,sha256=i175hPkR4tgf5SMZOrrCHjAE12mVlf6qUsu0mcJmJBE,297
 jaclang/compiler/passes/main/tests/fixtures/func2.jac,sha256=ZxgLe7VA57daLkqoB8MefdEE8dZIoFv2Dq-Zx-yHKxI,124
 jaclang/compiler/passes/main/tests/fixtures/game1.jac,sha256=oiTadkrYJRUo6ZkHUi7I54J_0GoTTtsNLhhofTlz0uY,263
@@ -164,9 +164,10 @@ jaclang/langserve/tests/test_server.py,sha256=psv23hfxQZnq_pGlY1Xf9S2oUJk2QpYMPm
 jaclang/langserve/utils.py,sha256=rtFO1OYrgU6RmFhNs43anZac79sUwe3oZxlYB0s3CXs,14522
 jaclang/plugin/__init__.py,sha256=5t2krHKt_44PrCTGojzxEimxpNHYVQcn89jAiCSXE_k,165
 jaclang/plugin/builtin.py,sha256=zNTbe5knJrGFgJRa4l4hMzzuij6iXFyVqRTxputUHIo,1307
-jaclang/plugin/default.py,sha256=eAM8CJ0hCV5bvxQgtIdb70EGiFAS8XE9N3Vxzzsygus,45213
-jaclang/plugin/feature.py,sha256=jJkpdaJ8dmz80RjcBn36Ik9GzrvpB5gD3kmhSBqykRc,16571
-jaclang/plugin/spec.py,sha256=LIIv2v7j9ij6VGH1_tIRingzn6OVgeEusZakNskQf9Y,14299
+jaclang/plugin/default.py,sha256=yluaC_rwOKZwbveMU3dhYScHeRCNt3jIV1cACfkBvG8,45438
+jaclang/plugin/feature.py,sha256=FhkzyPTk1N0faruRlyX13NYSPsRj6g--Jzfwes-_osE,16602
+jaclang/plugin/plugin.md,sha256=B252QTH3c8uZyvXTbGmZBafZtdXstFC5vT5jIN_gS4U,9994
+jaclang/plugin/spec.py,sha256=-ZaDdVfKLwQ0TgxvSZq4YQheNxyR6ljICIUthjRlm4g,14346
 jaclang/plugin/tests/__init__.py,sha256=rn_tNG8jCHWwBc_rx4yFkGc4N1GISb7aPuTFVRTvrTk,38
 jaclang/plugin/tests/fixtures/impl_match.jac,sha256=WEhcA1GlovusITEFO2bOjYYqiiULyYGKhM17uK2GqnI,91
 jaclang/plugin/tests/fixtures/impl_match_impl.jac,sha256=k1385r7Hdlq6mUKxEHa3VOKJUIWH08hYg2kErhbYwFM,31
@@ -179,13 +180,13 @@ jaclang/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jaclang/runtimelib/__init__.py,sha256=jDDYBCV82qPhmcDVk3NIvHbhng0ebSrXD3xrojg0-eo,34
 jaclang/runtimelib/architype.py,sha256=_4xCawHqmM5ASXwq9wxjStvqJlPdi9zJ5wvKU_QFt6U,7910
 jaclang/runtimelib/constructs.py,sha256=1ARnsPrDi1UvyaFRhGRhO0kj0fnIZ2HbHF7O3itB-ZQ,796
-jaclang/runtimelib/context.py,sha256=8WkCxs_qnp311R6FdKLBSOd8hS2XXnHJgQheU7QVWJE,5480
+jaclang/runtimelib/context.py,sha256=DjCkj1S6WLBWbNMkhUjqPYIhxqXV0XjJ1Mpjy7WR4g0,5538
 jaclang/runtimelib/importer.py,sha256=EzttjsUvcmuWkeqjyThRlCzsEu2rVHD8yhzy3WWOlQE,14463
 jaclang/runtimelib/machine.py,sha256=snxNctPZPlCZxYgQRcFBDl-BTvzG8lnwG-hrtkgytU8,10829
 jaclang/runtimelib/memory.py,sha256=SlzDYNi_R1Jj5WfLfW2y0Rta5GAD6CIKiONEo4LbfHI,5033
 jaclang/runtimelib/test.py,sha256=HRCl3cf0uPTe58Kcx_sBUb6ow8J53rnmpFOhA7g9oAA,2851
 jaclang/runtimelib/utils.py,sha256=P9gVE3XFhRzr745RCDXXIP391AcsL4aL_6HrXws_qa4,8155
-jaclang/settings.py,sha256=381YK66eXqDSnWhzTHMHfbmvwfQPEI_1yPLa0RFwzKo,3553
+jaclang/settings.py,sha256=iLgVEA2fyARM5u-qMMMaEvNr88Qxej2NGZviw-R95kU,3681
 jaclang/tests/fixtures/abc.jac,sha256=HZvLz6IEt3Snlgg8Czs-N4emLjg4fT3IbTo95d3Gdww,1747
 jaclang/tests/fixtures/access_checker.jac,sha256=UVoY7sYW-R0ms2HDA4HXQ5xJNiW0vEbY2T5CCY1avus,281
 jaclang/tests/fixtures/access_modifier.jac,sha256=NJHXbu_N_cWpTkjJnwcHzWkEk2kroaQ8aaalVxPXAW8,2587
@@ -198,7 +199,7 @@ jaclang/tests/fixtures/baddy.jac,sha256=waLlwMyW_JCE1x_SuVzRER1RBe1j3XiLTw-0Njzn
 jaclang/tests/fixtures/baddy.test.jac,sha256=Uq-Nlf44QUAtbOfDCbc9_ceLxmo31PILDTSzAv8nJq4,33
 jaclang/tests/fixtures/bar.jac,sha256=XZWOrzgMQed2R611DLfzCvWUT4a4gTYZXWRYvizMb18,782
 jaclang/tests/fixtures/blankwithentry.jac,sha256=lnMDDKyKnldsUIx1AVCIHt47KY3gR2CZYhox8663sLM,53
-jaclang/tests/fixtures/builtin_dotgen.jac,sha256=1CCJTSmMD1Zt_FkC-poPGyHRV3rIcst616UtYfuLIrE,1830
+jaclang/tests/fixtures/builtin_dotgen.jac,sha256=U2r_bmSsMDuJWuo9vYoRCgRIo9NA9-VkaaiacvAMeS8,1814
 jaclang/tests/fixtures/builtins_test.jac,sha256=1eJXipIFpa8IDjKv20TjAW_k4hTtJzNT1cKnQOAVt28,244
 jaclang/tests/fixtures/byllmissue.jac,sha256=vAwxzbRNx5yOM3HTDSH7wafPYXU7AunBOZmgdsT2rhc,86
 jaclang/tests/fixtures/chandra_bugs.jac,sha256=vcBjZ4P7S1PPUs-_0Stt779pus95RJTMs1x_-m0w7yY,282
@@ -226,7 +227,7 @@ jaclang/tests/fixtures/edge_ops.jac,sha256=b6XsApxIQUelPPAfReQor3ha2iDtAbNVpcihx
 jaclang/tests/fixtures/edges_walk.jac,sha256=nj_uxQ8Kx1x1ghIf010OngxlpPu8Ah1Y7kfYLGJ4oPo,798
 jaclang/tests/fixtures/edgetypeissue.jac,sha256=ZsJuNdtmD_fu2b7sDJ_tWZjoDI_rxouDEcSWkahhBS0,118
 jaclang/tests/fixtures/entry_exit.jac,sha256=Vl4f5TNCXEfTDurPiOnPWShW15RWAp5Rm4L1tI5bXOo,763
-jaclang/tests/fixtures/enum_inside_archtype.jac,sha256=EiuL9szE0ISfeczoVcnZyw0eK1n6vc6_koDf0cHgoh4,236
+jaclang/tests/fixtures/enum_inside_archtype.jac,sha256=_H4eKBDAO_DfCinAK3aWUOa59XUFvUZTZn5ClhrpdLc,428
 jaclang/tests/fixtures/err.impl.jac,sha256=bCW5RiPOoiEiBJCcCEsPsegBTA98mqY57UYiq5O2Skg,41
 jaclang/tests/fixtures/err.jac,sha256=Df-QWvUlVa2Tc3QtKXNv4VU63Xefmp_iC-BS-1VuOEI,62
 jaclang/tests/fixtures/err2.jac,sha256=x8h69NTVMGJa_UicY-CZblLMdeH09myTeiYqNFamiK0,50
@@ -295,7 +296,7 @@ jaclang/tests/fixtures/walker_update.jac,sha256=_bN3ASAN6LpfIQFfDMRnrx2oteM-ef7O
 jaclang/tests/fixtures/with_context.jac,sha256=cDA_4YWe5UVmQRgcpktzkZ_zsswQpV_T2Otf_rFnPy8,466
 jaclang/tests/test_bugs.py,sha256=tBPsIlSPqZDIz4QaScNRT-WdGIdJ0uU-aRBWq1XUZ6o,555
 jaclang/tests/test_cli.py,sha256=7PYJvJeKKb13yyP0TQ_pHbdRowWN5TI7kG-tNUESbaI,13461
-jaclang/tests/test_language.py,sha256=w8eRU328MzcB2P42RwYYKd-X6LvDjaQOuJBkdohyGXk,47199
+jaclang/tests/test_language.py,sha256=2bPSFWyXDiDkIG7T0CyC5opJUcgP5CIGlVOiS7oaYYU,47291
 jaclang/tests/test_man_code.py,sha256=ZdNarlZVfT_-8Jv3FjLplHw76tsvkCuISyfX3M4qxPg,5027
 jaclang/tests/test_reference.py,sha256=FISQpZbB8cmRoAeJOFfXUy13WVxykZjpkPSb1OTotfI,3340
 jaclang/tests/test_settings.py,sha256=TIX5uiu8H9IpZN2__uFiclcdCpBpPpcAwtlEHyFC4kk,1999
@@ -1529,7 +1530,7 @@ jaclang/vendor/typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjW
 jaclang/vendor/typing_extensions-4.12.2.dist-info/RECORD,sha256=XS4fBVrPI7kaNZ56Ggl2RGa76jySWLqTzcrUpZIQTVM,418
 jaclang/vendor/typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
 jaclang/vendor/typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451
-jaclang-0.7.23.dist-info/METADATA,sha256=XSXIBvGPoXmAI8OJ17_Xz6-bJAzWKOa6HzHwd1n-zZE,4914
-jaclang-0.7.23.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jaclang-0.7.23.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
-jaclang-0.7.23.dist-info/RECORD,,
+jaclang-0.7.24.dist-info/METADATA,sha256=ceCbSxyPiyxFmhTui2WbFLMHFhOKLDJsDTe5VVRWU9A,4965
+jaclang-0.7.24.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+jaclang-0.7.24.dist-info/entry_points.txt,sha256=8sMi4Tvi9f8tQDN2QAXsSA2icO27zQ4GgEdph6bNEZM,49
+jaclang-0.7.24.dist-info/RECORD,,

{jaclang-0.7.23.dist-info → jaclang-0.7.24.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any