jaclang 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

jaclang/__init__.py

@@ -0,0 +1,4 @@
+"""The Jac Programming Language."""
+from jaclang.jac.importer import handle_jac_error, jac_blue_import, jac_purple_import
+
+__all__ = ["jac_blue_import", "jac_purple_import", "handle_jac_error"]

jaclang/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CLI for jaclang."""
+from jaclang import jac_purple_import as jac_import
+
+cli = jac_import("cli")
+cmds = jac_import("cmds")
+
+cli.cmd_registry = cmds.cmd_reg  # type: ignore

jaclang/cli/cli.jac

@@ -0,0 +1,46 @@
+"""
+This is the implementation of the command line interface tool for the
+Jac language. It's built with the Jac language via bootstraping and
+represents the first such complete Jac program.
+"""
+
+import:py inspect;
+import:py argparse;
+import:py cmd;
+include:jac impl.cli_impl;
+
+
+object Command {
+    has func: callable,
+        sig: inspect.Signature;
+
+    can:private init(func: callable);
+    can call(*args: list, **kwargs: dict);
+}
+
+
+object CommandRegistry {
+    has:private registry: dict[str, Command],
+             sub_parsers: argparse._SubParsersActionp;
+    has:public parser: argparse.ArgumentParser;
+
+    can init;
+    can register(func: callable);
+    can get(name: str) -> Command;
+    can items -> dict[str, Command];
+}
+
+
+object CommandShell:cmd.Cmd {
+    static has intro: str = "Welcome to the Jac CLI!",
+               prompt: str = "jac> ";
+    has cmd_reg: CommandRegistry;
+
+    can init (cmd_reg: CommandRegistry);
+    can do_exit(arg: list) -> bool;
+    can default(line: str);
+}
+
+
+global cmd_registry = |> CommandRegistry;
+can start_cli;

jaclang/cli/cmds.jac

@@ -0,0 +1,14 @@
+"""
+This is the implementation of the command line interface tool for the
+Jac language. It's built with the Jac language via bootstraping and
+represents the first such production Jac program.
+"""
+import:jac from cli, cmd_registry as cmd_reg;
+
+include:jac impl.cmds_impl;
+
+@cmd_reg.register
+can load(filename: str);
+
+@cmd_reg.register
+can run(filename: str, entrypoint: str, args: list);

jaclang/cli/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang/cli/impl/cli_impl.jac

@@ -0,0 +1,93 @@
+"""Implemenation for Jac's command line interface."""
+
+:o:Command:a:init(func: callable) {
+    <s>.func = func;
+    <s>.sig = func |> inspect.signature;
+}
+
+:o:Command:a:call(*args: list, **kwargs: dict) {
+    return (*args, **kwargs) |> <s>.func;
+}
+
+:o:CommandRegistry:a:init {
+    <s>.registry = {};
+    <s>.parser = (prog="CLI") |> argparse.ArgumentParser;
+    <s>.sub_parsers =
+        (title="commands", dest="command") |> <s>.parser.add_subparsers;
+}
+
+:o:CommandRegistry:a:register(func: callable) {
+    name = func.__name__;
+    cmd = func |> Command;
+    <s>.registry[name] = cmd;
+    cmd_parser = name |> <s>.sub_parsers.add_parser;
+    for param_name, param in |> cmd.sig.parameters.items {
+        if param_name == "args" {
+            ('args', nargs=argparse.REMAINDER)
+                |> cmd_parser.add_argument;
+        }
+        elif param.default is param.empty {
+            (f"-{param_name[:1]}", f"--{param_name}",
+            required=True, type=param.annotation|>eval)
+                |> cmd_parser.add_argument;
+        }
+        else {
+            (f"-{param_name[:1]}", f"--{param_name}",
+            default=param.default, type=param.annotation|>eval)
+                |> cmd_parser.add_argument;
+        }
+    }
+    return func;
+}
+
+:o:CommandRegistry:a:get(name: str) -> Command {
+    return name |> <s>.registry.get;
+}
+
+:o:CommandRegistry:a:items -> dict[str, Command] {
+    return |> <s>.registry.items;
+}
+
+
+:o:CommandShell:a:init (cmd_reg: CommandRegistry) {
+    <s>.cmd_reg = cmd_reg;
+    <s> |> cmd.Cmd.__init__;
+}
+
+:o:CommandShell:a:do_exit(arg: list) -> bool {
+    return True;
+}
+
+:o:CommandShell:a:default(line: str) {
+    try {
+        args = |> line.split |> <s>.cmd_reg.parser.parse_args |> vars;
+        command = args["command"] |> <s>.cmd_reg.get;
+        if command {
+            args.pop("command");
+            ret = **args |> command.call;
+            if ret {
+                ret |> print;
+            }
+        }
+    }
+    except Exception as e {
+        e |> print;
+    }
+}
+
+:a:start_cli {
+    parser = cmd_registry.parser;
+    args = |> parser.parse_args;
+    command = args.command |> cmd_registry.get;
+    if command {
+        args = args |> vars;
+        "command" |> args.pop;
+        ret = **args |> command.call;
+        if ret {
+            ret |> print;
+        }
+    }
+    else {
+        shell = |> CommandShell(cmd_registry).cmdloop;
+    }
+}

jaclang/cli/impl/cmds_impl.jac

@@ -0,0 +1,26 @@
+"""Implementations for the jac command line interface."""
+import:py from os, path;
+
+:a:load(filename: str) {
+    if filename.endswith(".jac"){
+        [base, mod] = path.split(filename);
+        base = './' if not base else base;
+        mod=mod[:-4];
+        __jac_import__(target=mod, base_path=base);
+    } else {
+        "Not a .jac file." :> print;
+    }
+}
+
+
+:a:run(filename: str, entrypoint: str, args: list) {
+    if filename.endswith(".jac"){
+        [base, mod] = path.split(filename);
+        base = './' if not base else base;
+        mod=mod[:-4];
+        mod = __jac_import__(target=mod, base_path=base);
+        :> ((mod, entrypoint) :> getattr );
+    } else {
+        "Not a .jac file." :> print;
+    }
+}

jaclang/core/__init__.py

@@ -0,0 +1,12 @@
+"""Core primitives for Jaseci."""
+from jaclang import jac_blue_import
+
+prim = jac_blue_import("primitives")
+
+
+Object = prim.Object
+Node = prim.Node
+Edge = prim.Edge
+Walker = prim.Walker
+
+exec_ctx = prim.exec_ctx

jaclang/core/impl/__init__.py

@@ -0,0 +1 @@
+"""For setuptools to find this dir."""

jaclang/core/impl/arch_impl.jac

@@ -0,0 +1,112 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py from jaclang.jac.constant, EdgeDir;
+
+:o:Node:a:__call__
+(walk: Walker) {
+    if not (walk, Walker) :> isinstance {
+        raise ("Argument must be a Walker instance") :> TypeError;
+    }
+    <self> :> walk;
+}
+
+:o:Node:a:_jac_connect_node_
+(nd: Node, edg: Edge) -> Node {
+    (<self>, nd) :> edg._jac_attach_;
+    return <self>;
+}
+
+:o:Node:a:_jac_edges_to_nodes_
+(dir: EdgeDir) -> list[Node] {
+    ret_nodes = [];
+    if dir in [EdgeDir.OUT, EdgeDir.ANY] {
+        for i in <self>._jac_edges_[EdgeDir.OUT] {
+            ret_nodes.append(i._jac_target_);
+        }
+    } elif dir in [EdgeDir.IN, EdgeDir.ANY] {
+        for i in <self>._jac_edges_[EdgeDir.IN] {
+            ret_nodes.append(i._jac_source_);
+        }
+
+    }
+    return ret_nodes;
+}
+
+:o:Edge:a:__call__
+(walk: Walker) {
+    if not (walk, Walker) :> isinstance {
+        raise ("Argument must be a Walker instance") :> TypeError;
+    }
+    <self>._jac_target_ :> walk;
+}
+
+:o:Edge:a:_jac_apply_dir_
+(dir: EdgeDir) -> Edge {
+    <self>._jac_dir_ = dir;
+    return <self>;
+}
+
+:o:Edge:a:_jac_attach_
+(src: Node, trg: Node) -> Edge {
+    if <self>._jac_dir_ == EdgeDir.IN {
+        <self>._jac_source_ = trg;
+        <self>._jac_target_ = src;
+        <self> :> src._jac_edges_[EdgeDir.IN].append;
+        <self> :> trg._jac_edges_[EdgeDir.OUT].append;
+    } else {
+        <self>._jac_source_ = src;
+        <self>._jac_target_ = trg;
+        <self> :> src._jac_edges_[EdgeDir.OUT].append;
+        <self> :> trg._jac_edges_[EdgeDir.IN].append;
+    }
+
+    return <self>;
+}
+
+:o:Walker:a:__call__
+(nd: Node) {
+    <self>._jac_path_ = [];
+    <self>._jac_next_ = [nd];
+    walker_type = <self>.__class__.__name__;
+    node_type = nd.__class__.__name__;
+    while <self>._jac_next_ :> len {
+        nd = 0 :> <self>._jac_next_.pop;
+
+        for i in nd._jac_ds_entry_funcs {
+            if i['func'].__qualname__.split(".")[0] == node_type and
+                <self>:>type in i['types'] {
+                (nd, <self>) :> i['func'];
+            }
+        }
+        for i in <self>._jac_ds_entry_funcs {
+            if i['func'].__qualname__.split(".")[0] == walker_type and
+                (nd:>type in i['types'] or nd in i['types']) {  # if nd==root direct chec
+                (<self>, nd) :> i['func'];
+            }
+        }
+        for i in <self>._jac_ds_exit_funcs {
+            if i['func'].__qualname__.split(".")[0] == walker_type and
+            (nd:>type in i['types'] or nd in i['types']) {
+                (<self>, nd) :> i['func'];
+            }
+        }
+        for i in nd._jac_ds_exit_funcs {
+            if i['func'].__qualname__.split(".")[0] == node_type and
+                <self>:>type in i['types'] {
+                (nd, <self>) :> i['func'];
+            }
+        }
+        nd :> <self>._jac_path_.append;
+    }
+}
+
+:o:Walker:a:_jac_visit_
+(nds: list[Node]|list[Edge]) {
+    for i in nds {
+        i :> <self>._jac_next_.append;
+    }
+    return nds :> len;
+}
+
+:o:Walker:a:_jac_disengage_ {
+    <self>._jac_next_ = [];
+}

jaclang/core/impl/element_impl.jac

@@ -0,0 +1,95 @@
+"""Implementation for Jac's Element Abstractions"""
+
+:enum:AccessMode {
+    READ_ONLY,
+    READ_WRITE,
+    PRIVATE
+}
+
+:object:Element:ability:init
+(_jac_exec_ctx: ExecutionContext) {
+    <self>.__jinfo = _jac_exec_ctx :> ExecutionContext;
+}
+
+:object:Element:ability:_jac_make_public_ro {
+    <self>.__jinfo.access_mode = AccessMode.READ_ONLY;
+}
+
+:object:Element:ability:_jac_make_public_rw {
+    <self>.__jinfo.access_mode = AccessMode.READ_WRITE;
+}
+
+:object:Element:ability:_jac_make_private {
+    <self>.__jinfo.access_mode = AccessMode.PRIVATE;
+}
+
+:object:Element:ability:_jac_is_public_ro -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.READ_ONLY;
+}
+
+:object:Element:ability:_jac_is_public_rw -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.READ_WRITE;
+}
+
+:object:Element:ability:_jac_is_private -> bool {
+    return <self>.__jinfo.access_mode == AccessMode.PRIVATE;
+}
+
+:object:Element:ability:_jac_is_readable
+(caller_id: UUID) -> bool {
+    return (
+            caller_id == <self>.owner_id
+            or |> <self>.is_public_read
+            or caller_id in <self>.ro_access
+            or caller_id in <self>.rw_access
+        );
+}
+
+:object:Element:ability:_jac_is_writable
+(caller_id: UUID) -> bool {
+    return (
+            caller_id == <self>.owner_id
+            or |> <self>.is_public_write
+            or caller_id in <self>.rw_access
+        );
+}
+
+:object:Element:ability:_jac_give_access
+(caller_id: UUID, read_write: bool = False) {
+    if read_write {
+        caller_id |> <self>.rw_access.add;
+    }
+    else {
+        caller_id |> add .> ro_access .> <self>;
+    }
+}
+
+:object:Element:ability:_jac_revoke_access
+(caller_id: UUID) {
+    caller_id |> <self>.ro_access.discard;
+    caller_id |> <self>.rw_access.discard;
+}
+
+:object:Object:ability:_jac_on_entry
+(cls: type, triggers: list) {
+    can decorator(func: callable) -> callable {
+        cls._jac_ds_entry_funcs.append({'types': triggers, 'func': func});
+        can wrapper(*args: list, **kwargs: dict) -> callable {
+            return func(*args, **kwargs);
+        }
+        return wrapper;
+    }
+    return decorator;
+}
+
+:object:Object:ability:_jac_on_exit
+(cls: type, triggers: list) {
+    can decorator(func: callable) -> callable {
+        cls._jac_ds_exit_funcs.append({'types': triggers, 'func': func});
+        can wrapper(*args: list, **kwargs: dict) -> callable {
+            return func(*args, **kwargs);
+        }
+        return wrapper;
+    }
+    return decorator;
+}

jaclang/core/impl/exec_ctx_impl.jac

@@ -0,0 +1,17 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py from uuid, UUID, uuid4;
+
+:object:ExecutionContext:a:init
+(master: UUID, memory: Memory) {
+    <self>.master = master;
+    <self>.memory = memory;
+}
+
+:object:ExecutionContext:a:get_root
+() {
+    if <self>.master :> type == UUID {
+        <self>.master = Master();
+    }
+    return <self>.master.root_node;
+}
+

jaclang/core/impl/memory_impl.jac

@@ -0,0 +1,57 @@
+"""Implementation for Jac's Element Abstractions"""
+import:py sys;
+
+:object:Memory:ability:get_obj
+(caller_id: UUID, item_id: UUID, override: bool = False) -> Element? {
+    ret = item_id |> <self>.index.get;
+    if override or (ret is not None and caller_id |> ret.__is_readable) {
+        return ret;
+    }
+}
+
+:object:Memory:ability:has_obj
+(item_id: UUID) -> bool {
+    return item_id in <self>.index;
+}
+
+:object:Memory:ability:save_obj
+(caller_id: UUID, item: Element) {
+    if caller_id |> item.is_writable {
+        <self>.index[item.id] = item;
+        if item._persist {
+            item |> <self>.save_obj_list.add;
+        }
+    }
+    <self>.mem[item.id] = item;
+    if item._persist {
+        item |> <self>.save_obj_list.add;
+    }
+}
+
+:object:Memory:ability:del_obj
+(caller_id: UUID, item: Element) {
+    if caller_id |> item.is_writable {
+        <self>.index.pop(item.id);
+        if item._persist {
+            item |> <self>.save_obj_list.remove;
+        }
+    }
+}
+
+:object:Memory:ability:get_object_distribution -> dict {
+    dist = {};
+    for i in |> <self>.index.keys {
+        t = <self>.index[i] |> type;
+        if t in dist {
+            dist[t] += 1;
+        }
+        else {
+            dist[t] = 1;
+        }
+    }
+    return dist;
+}
+
+:object:Memory:ability:get_mem_size -> float {
+    return (<self>.index |> sys.getsizeof) / 1024.0;
+}

jaclang/core/primitives.jac

@@ -0,0 +1,104 @@
+"""Jac's Key Elemental Abstractions"""
+
+import:py from datetime, datetime;
+import:py from uuid, UUID, uuid4;
+import:py from jaclang.jac.constant, EdgeDir;
+
+include:jac impl.memory_impl;
+include:jac impl.exec_ctx_impl;
+include:jac impl.element_impl;
+include:jac impl.arch_impl;
+
+
+enum AccessMode;
+
+object Memory {
+    has index: dict[UUID, Element], save_queue: list[Element];
+
+    #* Main Accessors *#
+    can get_obj(caller_id: UUID, item_id: UUID,
+                override: bool = False) -> Element?;
+    can has_obj(item_id: UUID) -> bool;
+    can save_obj(caller_id: UUID, item: Element);
+    can del_obj(caller_id: UUID, item: Element);
+
+    #* Utility Functions *#
+    can get_object_distribution -> dict;
+    can get_mem_size -> float;
+}
+
+object ExecutionContext {
+    has master: Master,
+        memory: Memory;
+
+    can init(master: UUID, memory: Memory);
+    can get_root() -> Node;
+}
+
+global exec_ctx = ExecutionContext(:>uuid4, Memory());
+
+object ElementMetaData {
+    has jid: UUID = :>uuid4,
+        timestamp: datetime = :>datetime.now,
+        persist: bool = False,
+        access_mode: AccessMode = AccessMode.PRIVATE,
+        rw_access: set = :>set,
+        ro_access: set = :>set,
+        owner_id: UUID = exec_ctx.master,
+        mem: Memory = exec_ctx.memory;
+}
+
+object Element {
+    has _jinfo: ElementMetaData = ElementMetaData();
+
+    can _jac_make_public_ro;
+    can _jac_make_public_rw;
+    can _jac_make_private;
+    can _jac_is_public_ro -> bool;
+    can _jac_is_public_rw -> bool;
+    can _jac_is_private -> bool;
+    can _jac_is_readable(caller_id: UUID) -> bool;
+    can _jac_is_writable(caller_id: UUID) -> bool;
+    can _jac_give_access(caller_id: UUID, read_write: bool = False);
+    can _jac_revoke_access(caller_id: UUID);
+}
+
+object Object:Element {
+    static has _jac_ds_entry_funcs: list[dict]=[],
+               _jac_ds_exit_funcs: list[dict]=[];
+
+    static can _jac_on_entry(cls: type, triggers: list[type]);
+    static can _jac_on_exit(cls: type, triggers: list[type]);
+}
+
+object Node:Object {
+    has _jac_edges_: dict[EdgeDir, list[Edge]]
+        = {EdgeDir.IN: [], EdgeDir.OUT: []};
+
+    can __call__(walk: Walker);
+    can _jac_connect_node_(nd: Node, edg: Edge) -> Node;
+    can _jac_edges_to_nodes_(dir: EdgeDir) -> list[Node];
+}
+
+object Edge:Object {
+    has _jac_source_: Node?,
+        _jac_target_: Node?,
+        _jac_dir_: EdgeDir?;
+
+    can __call__(walk: Walker);
+    can _jac_apply_dir_(dir: EdgeDir) -> Edge;
+    can _jac_attach_(src: Node, trg: Node) -> Edge;
+}
+
+object Walker:Object {
+    has _jac_path_: list[Node] = [],
+        _jac_next_: list[Node] = [];
+
+    can __call__(nd: Node);
+    can _jac_visit_(nds: list[Node]|list[Edge]);
+    can _jac_disengage_;
+}
+
+object Master:Element {
+    has root_node: Node = Node();
+}

jaclang/jac/__init__.py

@@ -0,0 +1 @@
+"""Jac compiler tools."""