jaseci 1.4.2.6__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/extens/api/tests/test_walker_api.py

@@ -1,316 +0,0 @@
-from jaseci.prim.edge import Edge
-from jaseci.prim.node import Node
-from jaseci.utils.test_core import CoreTest
-
-
-class WalkerApiTest(CoreTest):
-    """Unit tests for Jac Walker APIs"""
-
-    fixture_src = __file__
-
-    def test_walker_yield(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["entering", 7])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [8])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [9])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [10])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["should start over now", "exiting"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["entering", 7])
-
-    def test_walker_yield_update(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["entering", 7])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [8])
-        ret = self.call(
-            self.mast, ["walker_run", {"name": "test_yield", "ctx": {"a": 2}}]
-        )
-        self.assertEqual(ret["report"], [3])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [4])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [5])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [6])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [7])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [8])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [9])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], [10])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["should start over now", "exiting"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield"}])
-        self.assertEqual(ret["report"], ["entering", 7])
-
-    def test_walker_yield_report(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], [7])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], [8])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], [9])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], [10])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], ["should start over now"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_report"}])
-        self.assertEqual(ret["report"], [7])
-
-    def test_walker_yield_disengage(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], [7])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], [8])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], [9])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], [10])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], ["should start over now"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_disengage"}])
-        self.assertEqual(ret["report"], [7])
-
-    def test_walker_yield_take(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], [7, "test"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], [8, "test"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], [9, "test"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], [10, "test"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], ["should start over now"])
-        ret = self.call(self.mast, ["walker_run", {"name": "test_yield_take"}])
-        self.assertEqual(ret["report"], [7, "test"])
-
-    def test_walker_smart_yield(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield"}])
-        before = self.mast._h.get_object_distribution()
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield"}])
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield"}])
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield"}])
-        after = self.mast._h.get_object_distribution()
-        self.assertEqual(before, after)
-        self.assertEqual(ret["report"], [{"id": 2}])
-
-    def test_walker_smart_yield_no_future(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield_no_future"}])
-        before = self.mast._h.get_object_distribution()
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield_no_future"}])
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield_no_future"}])
-        ret = self.call(self.mast, ["walker_run", {"name": "smart_yield_no_future"}])
-        after = self.mast._h.get_object_distribution()
-        self.assertEqual(before, after)
-        self.assertEqual(ret["report"], [{}])
-
-    def test_walker_deep_yield(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "deep_yield"}])
-        self.assertEqual(
-            ret["report"],
-            [
-                {},
-                {"id": 0},
-                {"id": 1},
-                {"id": 2},
-                {"id": 3},
-                {"id": 4},
-                {"id": 5},
-                {"id": 6},
-                {"id": 7},
-                {"id": 8},
-                {"id": 9},
-                {},
-                {"id": 0},
-                {"id": 1},
-                {"id": 2},
-                11,
-            ],
-        )
-
-    def test_walker_simple_yield(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        expected = [
-            "entry",
-            {"id": 0},
-            {"id": 1},
-            {"id": 2},
-            {"id": 3},
-            {"id": 4},
-            {"id": 5},
-            {"id": 6},
-            {"id": 7},
-            {"id": 8},
-            {"id": 9},
-            "entry",
-            {"id": 0},
-            {"id": 10},
-            {"id": 1},
-            {"id": 11},
-        ]
-        for i in range(16):
-            ret = self.call(self.mast, ["walker_run", {"name": "simple_yield"}])
-            self.assertEqual(ret["report"][0], expected[i])
-
-    def test_walker_deep_yield2(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "deep_yield2"}])
-        self.assertEqual(
-            ret["report"],
-            [
-                "entry",
-                {},
-                {"id": 0},
-                {"id": 1},
-                {"id": 2},
-                {"id": 3},
-                {"id": 4},
-                {"id": 5},
-                {"id": 6},
-                {"id": 7},
-                {"id": 8},
-                {"id": 9},
-                "entry",
-                {},
-                {"id": 0},
-                {"id": 10},
-                {"id": 1},
-                {"id": 11},
-            ],
-        )
-
-    def test_walker_deep_yield_no_leak(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        before = self.mast._h.get_object_distribution()
-        self.call(self.mast, ["walker_run", {"name": "deep_yield"}])
-        self.call(self.mast, ["walker_run", {"name": "deep_yield"}])
-        self.call(self.mast, ["walker_run", {"name": "deep_yield"}])
-        after = self.mast._h.get_object_distribution()
-        after.pop(Node)
-        after.pop(Edge)
-        self.assertEqual(before, after)
-
-    def test_walker_simple_yield_skip_test(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = []
-        for i in range(16):
-            ret += self.call(
-                self.mast, ["walker_run", {"name": "simple_yield_skip_test"}]
-            )["report"]
-        self.assertEqual(
-            ret,
-            [
-                "entry",
-                {},
-                "in_node",
-                {"id": 0},
-                "in_node",
-                {"id": 1},
-                "in_node",
-                {"id": 2},
-                "in_node",
-                {"id": 3},
-                "in_node",
-                {"id": 4},
-                5,
-                {"id": 5},
-                5,
-                {"id": 6},
-                5,
-                {"id": 7},
-                5,
-                {"id": 8},
-                5,
-                {"id": 9},
-                "entry",
-                {},
-                "in_node",
-                {"id": 0},
-                "in_node",
-                {"id": 10},
-                "in_node",
-                {"id": 1},
-                "in_node",
-                {"id": 11},
-            ],
-        )
-
-    def test_error_reporting_walker_only_actions(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("walker_yield.jac")}],
-        )
-        ret = []
-        self.call(self.mast, ["walker_run", {"name": "error_walker_action"}])
-        ret = self.call(self.mast, ["walker_run", {"name": "error_walker_action"}])
-        self.assertIn('cannot execute the statement "disengage ; "', ret["errors"][0])
-
-    def test_walker_stepping(self):
-        self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("fam.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_spawn_create", {"name": "create_fam"}])
-        jid = ret["jid"]
-        ret = self.call(self.mast, ["walker_prime", {"wlk": jid}])
-        ret = self.call(self.mast, ["walker_step", {"wlk": jid}])
-        self.log(ret)
-        self.assertEqual(len(ret["next_node_ids"]), 2)
-        ret = self.call(self.mast, ["walker_step", {"wlk": jid}])
-        self.assertEqual(len(ret["next_node_ids"]), 1)
-        ret = self.call(self.mast, ["walker_step", {"wlk": jid}])
-        self.assertEqual(len(ret["next_node_ids"]), 0)
-        ret = self.call(self.mast, ["walker_step", {"wlk": jid}])
-        self.assertEqual(len(ret["next_node_ids"]), 0)

jaseci/extens/api/user_api.py

@@ -1,166 +0,0 @@
-"""
-User API
-"""
-
-from jaseci.extens.api.interface import Interface
-from jaseci.jsorc.jsorc import JsOrc
-
-
-class UserApi:
-    """
-    User APIs for creating users (some functions should be override downstream)
-
-    These User APIs enable the creation and management of users on a Jaseci machine.
-    The creation of a user in this context is synonymous to the creation of a master
-    Jaseci object. These APIs are particularly useful when running a Jaseci server
-    or cluster in contrast to running JSCTL on the command line. Upon executing JSCTL
-    a dummy admin user (super_master) is created and all state is dumped to a session
-    file, though any users created during a JSCTL session will indeed be created as
-    part of that session's state.
-    """
-
-    @Interface.public_api(cli_args=["name"])
-    def user_create(
-        self,
-        name: str,
-        password: str = "",
-        global_init: str = "",
-        global_init_ctx: dict = {},
-        other_fields: dict = {},
-        send_email: bool = True,
-    ):
-        """
-        Create a new user (master object)
-
-        This API is used to create users and optionally set them up with a graph and
-        related initialization. In the context of
-        JSCTL, any name is sufficient and no additional information is required.
-        However, for Jaseci serving (whether it be the official Jaseci server, or a
-        custom overloaded server) additional fields are required and should be added
-        to the other_fields parameter as per the specifics of the encapsulating server
-        requirements. In the case of the official Jaseci server, the name field must
-        be a valid email, and a password field must be passed through other_fields.
-        A number of other optional parameters can also be passed through other_feilds.
-        \\vspace{3mm}\\par
-        This single API call can also be used to fully set up and initialize a user
-        by leveraging the global_init parameter. When set, this parameter attaches the
-        user to the global sentinel, creates a new graph for the user, sets it as the
-        active graph, then runs an initialization walker on the root node of this new
-        graph. The initialization walker is identified by the name assigned to
-        global_init. The default empty string assigned to global_init indicates this
-        global setup should not be run.
-
-        :param name: The user name to create. For Jaseci server this must be a valid
-            email address.
-        :param global_init: The name of an initialization walker. When set the user is
-            linked to the global sentinel and the walker is run on a new active graph
-            created for the user.
-        :param global_init_ctx: Context to preload for the initialization walker
-        :param other_fields: This parameter is used for additional fields required for
-            overloaded interfaces. This parameter is not used in JSCTL, but is used
-            by Jaseci server for the additional parameters of password, is_activated,
-            and is_superuser.
-        """
-        ret = {}
-        mast = self.user_creator(name, password, other_fields, send_email)
-        if type(mast) is dict:  # in case of upstream error
-            return mast
-        ret["user"] = mast.serialize()
-        self.seek_committer(mast)
-        if len(global_init):
-            ret["global_init"] = self.user_global_init(
-                mast, global_init, global_init_ctx
-            )
-        ret["success"] = True
-        return ret
-
-    @Interface.admin_api(cli_args=["name"])
-    def user_delete(self, name: str):
-        """
-        Delete new user (master object)
-
-        This API is used to delete a user account.
-
-        :param name: The user name to delete. For Jaseci server this must
-        be a valid email address.
-
-        """
-        ret = {}
-        ret["success"] = self.user_destroyer(name)
-        if not ret["success"]:
-            ret["status_code"] = 400
-        return ret
-
-    @Interface.private_api(cli_args=["name"])
-    def user_deleteself(self):
-        """
-        Delete self (master object)
-
-        This API is used to delete a user account.
-        """
-        ret = {}
-        ret["success"] = self.user_destroyer(self.name)
-        if not ret["success"]:
-            ret["status_code"] = 400
-        return ret
-
-    def user_creator(
-        self, name, password: str = "", other_fields: dict = {}, send_email=True
-    ):
-        """
-        Abstraction for user creation for elegant overriding
-        """
-
-        return JsOrc.master(h=self._h, name=name)
-
-    def superuser_creator(self, name, password: str = "", other_fields: dict = {}):
-        """
-        Abstraction for super user creation for elegant overriding
-        """
-
-        return JsOrc.super_master(h=self._h, name=name)
-
-    def user_global_init(
-        self,
-        mast,
-        global_init: str = "",
-        global_init_ctx: dict = {},
-    ):
-        """
-        Create a master instance and return root node master object
-
-        other_fields used for additional fields for overloaded interfaces
-        (i.e., Dango interface)
-        """
-        return mast.sentinel_active_global(
-            auto_run=global_init,
-            auto_run_ctx=global_init_ctx,
-            auto_create_graph=True,
-        )
-
-    def user_destroyer(self, name: str):
-        """
-        Permanently delete master with given id
-        """
-        pass
-
-    @Interface.private_api()
-    def user_search(
-        self,
-        name: str,
-        detailed: bool = False,
-        create_if_not_exist: bool = False,
-        create_fields: dict = {},
-    ):
-        """
-        Search for user and returns its master jid.
-        Create new one if the user doesn't already exist, optionally.
-        create_fields will be forwarded to the user create endpoint, including
-            password
-            global_init
-            global_init_ctx
-            other_fields
-            send_email
-        See the user_create API for more details.
-        """
-        pass