jaseci 1.4.1.8__py3-none-any.whl → 1.4.2__py3-none-any.whl

jaseci/jsorc/tests/test_actions.py

@@ -4,6 +4,26 @@ from jaseci.utils.utils import TestCaseHelper
 import jaseci.jsorc.live_actions as jla
 import jaseci.jsorc.remote_actions as jra
 from jaseci.jsorc.live_actions import gen_remote_func_hook
+from pydantic import BaseModel
+from typing import Any, List, Mapping, Optional
+
+
+class RequestBody(BaseModel):
+    a: str
+    b: str
+    c: str
+    d: Optional[List[Any]] = None
+    e: str = None
+    f: str = ""
+    g: Optional[Mapping[Any, Any]] = None
+
+
+def proc_req_body(route, body: RequestBody):
+    if "d" in body.__dict__:
+        body.__dict__["*d"] = body.__dict__.pop("d")
+    if "g" in body.__dict__:
+        body.__dict__["**g"] = body.__dict__.pop("g")
+    return route(body)
 
 
 class JacActionsTests(TestCaseHelper, TestCase):
@@ -11,6 +31,9 @@ class JacActionsTests(TestCaseHelper, TestCase):
 
     def setUp(self):
         super().setUp()
+        jra.remote_actions = {}
+        jra.registered_apis = []
+        jra.registered_endpoints = []
 
     def tearDown(self):
         super().tearDown()
@@ -71,6 +94,445 @@ class JacActionsTests(TestCaseHelper, TestCase):
 
         assert kwargs["json"] == payload
 
+    @patch("requests.post")
+    def test_remote_action_with_args_only(self, mock_post):
+        @jla.jaseci_action(act_group=["test"], allow_remote=True)
+        def args(a, b, c, *d, e=None, f=""):
+            return {"a": a, "b": b, "c": c, "*d": d, "e": e, "f": f}
+
+        app = jra.serv_actions()
+        self.assertEqual(
+            jra.remote_actions,
+            {"test.args": ["a", "b", "c", "*d", "e", "f"]},
+        )
+
+        remote_action = gen_remote_func_hook(
+            url="https://example.com/api/v1/endpoint",
+            act_name="test.args",
+            param_names=["a", "b", "c", "*d", "e", "f"],
+        )
+
+        #################################################
+        # --------------- complete call --------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            "4",  # inside "*d": [4]
+            "5",  # inside "*d": [4, 5]
+            "6",  # inside "*d": [4, 5, 6]
+            e="1",  # e
+            f="2",  # f
+        )
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": ["4", "5", "6"],
+                "e": "1",
+                "f": "2",
+            },
+            mock_post.call_args[1]["json"],
+        )
+
+        #################################################
+        # ---------------- no args call --------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            e="1",  # e
+            f="2",  # f
+        )
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "e": "1",
+                "f": "2",
+            },
+            mock_post.call_args[1]["json"],
+        )
+
+        # --------------------------------------------- action call --------------------------------------------- #
+
+        route = app.routes[-1].endpoint
+
+        ########################################################
+        # --------------- complete action call --------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": ("4", "5", "6"),
+                "e": "1",
+                "f": "2",
+            },
+            proc_req_body(
+                route,
+                RequestBody(
+                    a="1",
+                    b="2",
+                    c="3",
+                    d=["4", "5", "6"],
+                    e="1",
+                    f="2",
+                ),
+            ),
+        )
+
+        ########################################################
+        # ---------------- no args action call --------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": (),
+                "e": "1",
+                "f": "2",
+            },
+            proc_req_body(
+                route,
+                RequestBody(
+                    a="1",
+                    b="2",
+                    c="3",
+                    e="1",
+                    f="2",
+                ),
+            ),
+        )
+
+    @patch("requests.post")
+    def test_remote_action_with_kwargs_only(self, mock_post):
+        @jla.jaseci_action(act_group=["test"], allow_remote=True)
+        def kwargs(a, b, c, e=None, f="", **g):
+            return {"a": a, "b": b, "c": c, "e": e, "f": f, "**g": g}
+
+        app = jra.serv_actions()
+        self.assertEqual(
+            jra.remote_actions,
+            {"test.kwargs": ["a", "b", "c", "e", "f", "**g"]},
+        )
+
+        remote_action = gen_remote_func_hook(
+            url="https://example.com/api/v1/endpoint",
+            act_name="test.kwargs",
+            param_names=["a", "b", "c", "e", "f", "**g"],
+        )
+
+        #################################################
+        # --------------- complete call --------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            e="1",  # e
+            f="2",  # f
+            g="3",  # inside "**g": {"g": 3}
+            h="4",  # inside "**g": {"g": 3, "h": 4}
+            i="5",  # inside "**g": {"g": 3, "h": 4, "i": 5}
+        )
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            mock_post.call_args[1]["json"],
+        )
+
+        #################################################
+        # --------------- no kwargs call -------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            e="1",  # e
+            f="2",  # f
+        )
+
+        self.assertEqual(
+            {"a": "1", "b": "2", "c": "3", "e": "1", "f": "2"},
+            mock_post.call_args[1]["json"],
+        )
+
+        # --------------------------------------------- action call --------------------------------------------- #
+
+        route = app.routes[-1].endpoint
+
+        ########################################################
+        # --------------- complete action call --------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            proc_req_body(
+                route,
+                RequestBody(
+                    a="1",
+                    b="2",
+                    c="3",
+                    e="1",
+                    f="2",
+                    g={"g": "3", "h": "4", "i": "5"},
+                ),
+            ),
+        )
+
+        ########################################################
+        # --------------- no kwargs action call -------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "e": "1",
+                "f": "2",
+                "**g": {},
+            },
+            proc_req_body(route, RequestBody(a="1", b="2", c="3", e="1", f="2")),
+        )
+
+    @patch("requests.post")
+    def test_remote_action_with_args_kwargs(self, mock_post):
+        @jla.jaseci_action(act_group=["test"], allow_remote=True)
+        def args_kwargs(a, b, c, *d, e=None, f="", **g):
+            return {"a": a, "b": b, "c": c, "*d": d, "e": e, "f": f, "**g": g}
+
+        app = jra.serv_actions()
+        self.assertEqual(
+            jra.remote_actions,
+            {"test.args_kwargs": ["a", "b", "c", "*d", "e", "f", "**g"]},
+        )
+
+        remote_action = gen_remote_func_hook(
+            url="https://example.com/api/v1/endpoint",
+            act_name="test.args_kwargs",
+            param_names=["a", "b", "c", "*d", "e", "f", "**g"],
+        )
+
+        #################################################
+        # --------------- complete call --------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            "4",  # inside "*d": [4]
+            "5",  # inside "*d": [4, 5]
+            "6",  # inside "*d": [4, 5, 6]
+            e="1",  # e
+            f="2",  # f
+            g="3",  # inside "**g": {"g": 3}
+            h="4",  # inside "**g": {"g": 3, "h": 4}
+            i="5",  # inside "**g": {"g": 3, "h": 4, "i": 5}
+        )
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": ["4", "5", "6"],
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            mock_post.call_args[1]["json"],
+        )
+
+        #################################################
+        # --------------- no kwargs call -------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            "4",  # inside "*d": [4]
+            "5",  # inside "*d": [4, 5]
+            "6",  # inside "*d": [4, 5, 6]
+            e="1",  # e
+            f="2",  # f
+        )
+
+        self.assertEqual(
+            {"a": "1", "b": "2", "c": "3", "*d": ["4", "5", "6"], "e": "1", "f": "2"},
+            mock_post.call_args[1]["json"],
+        )
+
+        #################################################
+        # ---------------- no args call --------------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            e="1",  # e
+            f="2",  # f
+            g="3",  # inside "**g": {"g": 3}
+            h="4",  # inside "**g": {"g": 3, "h": 4}
+            i="5",  # inside "**g": {"g": 3, "h": 4, "i": 5}
+        )
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            mock_post.call_args[1]["json"],
+        )
+
+        #################################################
+        # ---------- no args and kwargs call ---------- #
+        #################################################
+
+        remote_action(
+            "1",  # a
+            "2",  # b
+            "3",  # c
+            e="1",  # e
+            f="2",  # f
+        )
+
+        self.assertEqual(
+            {"a": "1", "b": "2", "c": "3", "e": "1", "f": "2"},
+            mock_post.call_args[1]["json"],
+        )
+
+        # --------------------------------------------- action call --------------------------------------------- #
+
+        route = app.routes[-1].endpoint
+
+        ########################################################
+        # --------------- complete action call --------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": ("4", "5", "6"),
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            proc_req_body(
+                route,
+                RequestBody(
+                    a="1",
+                    b="2",
+                    c="3",
+                    d=["4", "5", "6"],
+                    e="1",
+                    f="2",
+                    g={"g": "3", "h": "4", "i": "5"},
+                ),
+            ),
+        )
+
+        ########################################################
+        # --------------- no kwargs action call -------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": ("4", "5", "6"),
+                "e": "1",
+                "f": "2",
+                "**g": {},
+            },
+            proc_req_body(
+                route, RequestBody(a="1", b="2", c="3", d=["4", "5", "6"], e="1", f="2")
+            ),
+        )
+
+        ########################################################
+        # ---------------- no args action call --------------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": (),
+                "e": "1",
+                "f": "2",
+                "**g": {"g": "3", "h": "4", "i": "5"},
+            },
+            proc_req_body(
+                route,
+                RequestBody(
+                    a="1",
+                    b="2",
+                    c="3",
+                    e="1",
+                    f="2",
+                    g={"g": "3", "h": "4", "i": "5"},
+                ),
+            ),
+        )
+
+        ########################################################
+        # ---------- no args and kwargs action call ---------- #
+        ########################################################
+
+        self.assertEqual(
+            {
+                "a": "1",
+                "b": "2",
+                "c": "3",
+                "*d": (),
+                "e": "1",
+                "f": "2",
+                "**g": {},
+            },
+            proc_req_body(route, RequestBody(a="1", b="2", c="3", e="1", f="2")),
+        )
+
     def test_setup_decorated_as_startup(self):
         @jla.jaseci_action(act_group=["ex"], allow_remote=True)
         def setup(param: str = ""):

jaseci/prim/ability.py

@@ -80,12 +80,6 @@ class Ability(Element, JacCode, Interp):
         else:
             try:
                 result = func(*param_list["args"], **param_list["kwargs"])
-            except TypeError as e:
-                params = str(inspect.signature(func))
-                interp.rt_error(
-                    f"Invalid arguments {param_list} to action call {self.name}! Valid paramters are {params}.",
-                    jac_ast,
-                )
             except Exception as e:
                 interp.rt_error(e, jac_ast, True)
         t = time.time() - ts

jaseci/prim/edge.py

@@ -103,8 +103,13 @@ class Edge(Element, Anchored):
         """
         Write self through hook to persistent storage
         """
+
         if self.is_fast():
             self._persist = False
+            if self.from_node_id:
+                self.from_node().save()
+            if self.to_node_id:
+                self.to_node().save()
         super().save()
 
     def destroy(self):

jaseci/prim/node.py

@@ -52,16 +52,23 @@ class Node(Element, Anchored):
         for k in self.fast_edges.keys():
             for v in self.fast_edges[k]:
                 link_order = [v[0], self.jid] if v[1] == FROM else [self.jid, v[0]]
-                edge = Edge(
-                    m_id=self._m_id, h=self._h, kind="edge", name=k, auto_save=False
-                )
-                edge.from_node_id = link_order[0]
-                edge.to_node_id = link_order[1]
-                edge.bidirected = v[1] == BI
-                edge.jid = v[2] if len(v) > 2 else uuid.uuid4().urn
-                edge.context = v[3] if len(v) > 3 else {}
-                edge.save()
-                self._fast_edge_ids.add_obj(edge)
+                edge = self._h.get_obj(self._m_id, v[2])
+                if edge:
+                    v[3] = edge.context
+                else:
+                    edge = Edge(
+                        m_id=self._m_id, h=self._h, kind="edge", name=k, auto_save=False
+                    )
+                    edge.from_node_id = link_order[0]
+                    edge.to_node_id = link_order[1]
+                    edge.bidirected = v[1] == BI
+                    edge.jid = v[2] if len(v) > 2 else uuid.uuid4().urn
+                    edge.context = v[3] if len(v) > 3 else {}
+                    # old `edge.save()` might be confusing
+                    # this line doesn't mean it has to be saved on db
+                    # it only needs to be available on cache (memory, redis)
+                    self._h.commit_obj_to_cache(edge, True)
+                self._fast_edge_ids.add_obj(edge, bypass=True)
 
     def smart_add_edge(self, obj):
         # make sure fast edges built

jaseci/prim/sentinel.py

@@ -145,7 +145,10 @@ class Sentinel(Element, JacCode, SentinelInterp):
         """Returns the architype that matches object"""
         ret = self.arch_ids.get_obj_by_name(name=obj.name, kind=obj.kind)
         if ret is None:
-            self.rt_error(f"Unable to find architype for {obj.name}, {obj.kind}")
+            self.rt_subtle_error(
+                f"Unable to find architype for {obj.name}, {obj.kind}",
+                self._cur_jac_ast,
+            )
         return ret
 
     def run_tests(self, specific=None, profiling=False, detailed=False, silent=False):

jaseci/tests/jac_test_code.py

@@ -1186,3 +1186,108 @@ struct_types = """
         report [a.basic.apple.apple, a.basic.apple.orange];
     }
     """
+
+
+simple_graph = """
+node a1 {has val = 0;}
+node a2 {has val = 0;}
+node a3 {has val = 0;}
+node b1 {has val = 0;}
+node b2 {has val = 0;}
+edge e1 {has val = 0;}
+edge e2 {has val = 0;}
+edge e3 {has val = 0;}
+
+walker sample {
+    root {
+        take --> node::a1 else: take spawn here +[e1]+> node::a1;
+        take --> node::b1 else: take spawn here ++> node::b1;
+    }
+
+    a1: take --> node::a2 else {
+        report --> node::a2;
+        report -[e2]-> node::a2;
+        take spawn here +[e2]+> node::a2;
+    }
+    a2: take --> node::a3 else: take spawn here +[e3]+> node::a3;
+    b1: take --> node::b2 else: take spawn here ++> node::b2;
+}
+
+walker sample2 {
+    root {
+        take --> node::a1;
+        take --> node::b1;
+    }
+    a1: take --> node::a2;
+    a2: take --> node::a3;
+    a3: here.val = 1;
+    b1: take --> node::b2;
+    b2: here.val = 1;
+}
+
+walker sample3 {
+    root {
+        take --> node::a1;
+        take --> node::b1;
+    }
+    a1 {
+        -[e2]->.edge[0].val = 1;
+        take --> node::a2;
+    }
+    a2 {
+        take --> node::a3;
+        here not --> node::a3;
+    }
+    a3: here.val = 2;
+    b1: take --> node::b2;
+}
+"""
+
+simple_graph2 = """
+node a1 {has val = 0;}
+edge e1 {has val = 0;}
+
+walker sample {
+    root: report spawn here <+[e1]+ node::a1;
+}
+
+walker sample2 {
+    root: report <-[e1]- node::a1.edge[0].val;
+    a1 {
+        --> node::root.edge[0].val = 4;
+        report -[e1]->.edge[0].val;
+        take --> node::root;
+    }
+}
+
+walker sample3 {
+    root {
+        report <-[e1]- node::a1.edge[0].val;
+        take <-[e1]- node::a1;
+    }
+
+    a1: report -[e1]->.edge[0].val;
+}
+
+walker sample4 {
+    root {
+        <-- node::a1.edge[0].val = 6;
+        report <-[e1]- node::a1.edge[0].val;
+        take <-[e1]- node::a1;
+    }
+    a1: report -[e1]-> node::root.edge[0].val;
+}
+
+walker sample5 {
+    root: report <-[e1]-.edge[0].val;
+    a1 {
+        report -[e1]-> node::root.edge[0].val;
+        take -[e1]-> node::root;
+    }
+}
+
+walker sample6 {
+    root: <-[e1]- node::a1.edge[0].val = 8;
+    a1: report --> node::root.edge[0].val;
+}
+"""

jaseci/tests/test_stripe.py

@@ -42,6 +42,7 @@ class StripeTests(CoreTest):
         stripe.Subscription.modify = Mock()
         stripe.Invoice.retrieve = Mock()
         stripe.SubscriptionItem.create_usage_record = Mock()
+        stripe.SubscriptionItem.list_usage_record_summaries = Mock()
         stripe.checkout.Session.create = Mock()
         stripe.billing_portal.Session.create = Mock()
 
@@ -194,6 +195,10 @@ class StripeTests(CoreTest):
     def test_stripe_create_usage_report(self, ret):
         stripe.SubscriptionItem.create_usage_record.assert_called()
 
+    @jac_testcase("stripe.jac", "list_usage_report")
+    def test_stripe_list_usage_report(self, ret):
+        stripe.SubscriptionItem.list_usage_record_summaries.assert_called()
+
     @jac_testcase("stripe.jac", "create_checkout_session")
     def test_stripe_create_checkout_session(self, ret):
         stripe.checkout.Session.create.assert_called_once_with(