jaseci 1.4.0.9__py3-none-any.whl → 1.4.0.11__py3-none-any.whl

jaseci/api/queue_api.py

@@ -2,6 +2,8 @@
 Queue api functions as a mixin
 """
 from jaseci.api.interface import Interface
+from jaseci import JsOrc
+from jaseci.svc.task_svc import TaskService
 
 
 class QueueApi:
@@ -16,23 +18,25 @@ class QueueApi:
         """
         Monitor Queues
         """
-        if not self._h.task.is_running():
+        task = JsOrc.svc("task", TaskService)
+        if not task.is_running():
             return "Task hook is not yet initialized!"
 
         if not task_id:
-            return self._h.task.inspect_tasks()
+            return task.inspect_tasks()
         else:
-            return self._h.task.get_by_task_id(task_id)
+            return task.get_by_task_id(task_id)
 
     @Interface.private_api(allowed_methods=["get"])
     def walker_queue_wait(self, task_id: str, timeout: int = 30):
         """
         Wait Queues
         """
-        if not self._h.task.is_running():
+        task = JsOrc.svc("task", TaskService)
+        if not task.is_running():
             return "Task hook is not yet initialized!"
 
         if not task_id:
             return "Task id is required!"
         else:
-            return self._h.task.get_by_task_id(task_id, True, timeout)
+            return task.get_by_task_id(task_id, True, timeout)

jaseci/api/tests/test_global_api.py

@@ -1,4 +1,5 @@
 from jaseci.utils.test_core import CoreTest
+from jaseci import JsOrc
 import jaseci.tests.jac_test_code as jtc
 
 
@@ -10,11 +11,10 @@ class GlobalApiTest(CoreTest):
     def setUp(self):
         super().setUp()
 
-        self.smast2 = self.meta.build_super_master(h=self.smast._h)
+        self.smast2 = JsOrc.super_master(h=self.smast._h)
         self.smast.sentinel_register(name="test", code=jtc.basic)
 
-        self.mast = self.meta.build_master()
-        self.mast2 = self.meta.build_super_master(h=self.mast._h)
+        self.mast2 = JsOrc.master(h=self.mast._h)
         self.mast.sentinel_register(name="test", code=jtc.basic)
 
     def tearDown(self):

jaseci/api/tests/test_logger_api.py

@@ -31,9 +31,9 @@ class LoggerApiTest(CoreTest):
         self.logger_off()
 
         ret = self.call(self.smast, ["logger_get", {}])
-
-        self.assertEqual(len(ret), 1)
-        self.assertTrue(ret[0]["log"].endswith("Hello world!"))
+        self.assertGreaterEqual(len(ret), 1)
+        self.assertLessEqual(len(ret), 5)
+        self.assertTrue(ret[-1]["log"].endswith("Hello world!"))
 
     def test_limited_sliding_buffer(self):
         buffer = LimitedSlidingBuffer(max_size=25)

jaseci/api/user_api.py

@@ -2,7 +2,7 @@
 User API
 """
 from jaseci.api.interface import Interface
-from jaseci.svc.meta import MetaService
+from jaseci import JsOrc
 
 
 class UserApi:
@@ -107,14 +107,14 @@ class UserApi:
         Abstraction for user creation for elegant overriding
         """
 
-        return MetaService().build_master(h=self._h, name=name)
+        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 MetaService().build_super_master(h=self._h, name=name)
+        return JsOrc.super_master(h=self._h, name=name)
 
     def user_global_init(
         self,

jaseci/api/webhook_api.py

@@ -3,8 +3,10 @@ Webhook API
 """
 from jaseci.api.interface import Interface
 from fastapi import HTTPException
-from json import loads
-from jaseci.svc import MetaService
+from jaseci import JsOrc
+from jaseci.svc.stripe_svc import StripeService
+
+import stripe as _stripe
 
 
 class WebhookApi:
@@ -18,8 +20,8 @@ class WebhookApi:
         req_body = _req_ctx["body"]
 
         if provider == "stripe":
-            stripe_service = MetaService().get_service("stripe")
-            stripe = stripe_service.poke()
+            stripe_service = JsOrc.svc("stripe", StripeService)
+            stripe = stripe_service.poke(_stripe)
 
             # to be updated
             stripe_service.get_event(_raw_req_ctx, _req_ctx["headers"])

jaseci/attr/action.py

@@ -9,6 +9,9 @@ from jaseci.jac.jac_set import JacSet
 import inspect
 import time
 
+from jaseci import JsOrc
+from jaseci.utils.actions.actions_manager import ActionManager
+
 # ACTION_PACKAGE = 'jaseci.actions.'
 
 
@@ -55,7 +58,10 @@ class Action(Item):
         self.do_auto_conversions(args, param_list)
         args = args[0] + args[4]
         hook = scope.parent._h
-        hook.meta.app.pre_action_call_hook() if hook.meta.run_svcs else None
+
+        action_manager = JsOrc.get("action_manager", ActionManager)
+        action_manager.pre_action_call_hook()
+
         ts = time.time()
         if "meta" in args:
             result = func(
@@ -85,7 +91,7 @@ class Action(Item):
                 )
                 raise
         t = time.time() - ts
-        hook.meta.app.post_action_call_hook(
-            self.value, t
-        ) if hook.meta.run_svcs else None
+
+        action_manager.post_action_call_hook(self.value, t)
+
         return result

jaseci/element/master.py

@@ -17,8 +17,10 @@ from jaseci.api.jac_api import JacApi
 from jaseci.api.user_api import UserApi
 from jaseci.api.queue_api import QueueApi
 from jaseci.api.webhook_api import WebhookApi
+from jaseci import JsOrc
 
 
+@JsOrc.context(name="master")
 class Master(
     Element,
     Interface,

jaseci/element/super_master.py

@@ -11,8 +11,10 @@ from jaseci.api.global_api import GlobalApi
 from jaseci.api.super_api import SuperApi
 from jaseci.api.actions_api import ActionsApi
 from jaseci.api.prometheus_api import PrometheusApi
+from jaseci import JsOrc
 
 
+@JsOrc.context(name="super_master")
 class SuperMaster(
     Master,
     LoggerApi,

jaseci/hook/memory.py

@@ -1,8 +1,10 @@
 from json import dumps, loads
 import sys
 from jaseci.utils.utils import find_class_and_import
+from jaseci import JsOrc
 
 
+@JsOrc.repository(name="hook")
 class MemoryHook:
     """
     Set of virtual functions to be used as hooks to allow access to
@@ -219,7 +221,7 @@ class MemoryHook:
     ###################################################
 
     def find_class_and_import(self, j_type, mod):
-        cls = self.meta.get_context(j_type)
+        cls = JsOrc.ctx_cls(j_type)
 
         if not cls:
             cls = find_class_and_import(j_type, mod)

jaseci/hook/redis.py

@@ -5,9 +5,10 @@ core engine.
 import json
 
 import jaseci as core_mod
-from jaseci.svc import ProxyService
 from jaseci.utils.json_handler import JaseciJsonDecoder
 from .memory import MemoryHook
+from jaseci import JsOrc
+from jaseci.svc.redis_svc import RedisService
 
 
 #################################################
@@ -15,10 +16,10 @@ from .memory import MemoryHook
 #################################################
 
 
+@JsOrc.repository(name="hook", priority=1)
 class RedisHook(MemoryHook):
-    def __init__(self):
-        # proxy redis, to be overriden by build_apps
-        self.redis = ProxyService()
+    def __init__(self, redis: RedisService = None):
+        self.redis = JsOrc.svc("redis", RedisService)
         self.red_touch_count = 0
 
         super().__init__()

jaseci/jac/interpreter/interp.py

@@ -4,6 +4,8 @@ Interpreter for jac code in AST form
 This interpreter should be inhereted from the class that manages state
 referenced through self.
 """
+from jaseci import JsOrc
+from jaseci.svc.task_svc import TaskService
 from jaseci.utils.utils import is_jsonable, parse_str_token, uuid_re
 from jaseci.element.element import Element
 from jaseci.graph.node import Node
@@ -20,6 +22,7 @@ from jaseci.jac.machine.jac_value import jac_elem_unwrap as jeu
 from jaseci.jac.machine.jac_value import jac_wrap_value as jwv
 from copy import copy, deepcopy
 from base64 import b64decode
+from itertools import pairwise
 
 from jaseci.jac.jsci_vm.op_codes import JsCmp
 
@@ -794,12 +797,14 @@ class Interp(VirtualMachine):
             elif kid[0].name == "KW_SYNC":
                 self.run_atom(kid[1])
                 val = self.pop()
-                task_func = self._h.task
-                if not task_func.is_running():
-                    raise Exception("Task hook is not yet initialized!")
                 self.push(
                     JacValue(
-                        self, value=task_func.get_by_task_id(val.value["result"], True)
+                        self,
+                        value=(
+                            JsOrc.svc("task")
+                            .poke(TaskService)
+                            .get_by_task_id(val.value["result"], True)
+                        ),
                     )
                 )
             else:
@@ -1154,6 +1159,13 @@ class Interp(VirtualMachine):
                     result = JacValue(
                         self, value=atom_res.value.index(min(atom_res.value))
                     )
+                elif op == "pairwise":
+                    result = JacValue(
+                        self, value=[list(s) for s in pairwise(atom_res.value)]
+                    )
+                elif op == "unique":
+                    result = JacValue(self, value=list(set(atom_res.value)))
+
                 elif len(kid) < 2 and op == "pop":
                     result = JacValue(self, value=atom_res.value.pop())
                     self.candidate_writethrough()

jaseci/jac/tests/test_book.py

@@ -5,7 +5,7 @@ from unittest import TestCase
 import jaseci.jac.tests.book_code as jtc
 from jaseci.actor.sentinel import Sentinel
 from jaseci.graph.graph import Graph
-from jaseci.svc import MetaService
+from jaseci import JsOrc
 from jaseci.utils.utils import TestCaseHelper
 
 
@@ -14,7 +14,7 @@ class JacBookTests(TestCaseHelper, TestCase):
 
     def setUp(self):
         super().setUp()
-        self.sent = Sentinel(m_id=0, h=MetaService().build_hook())
+        self.sent = Sentinel(m_id=0, h=JsOrc.hook())
         self.gph = Graph(m_id=0, h=self.sent._h)
         self.old_stdout = sys.stdout
         self.new_stdout = io.StringIO()

jaseci/jsctl/jsctl.py

@@ -6,17 +6,17 @@ import functools
 import json
 import os
 import pickle
-
+import webbrowser
 import click
 import requests
 from click_shell import shell
 from click.testing import CliRunner
 from jaseci import __version__
 from jaseci.element.super_master import SuperMaster
-from jaseci.svc import MetaService
 from jaseci.utils.utils import copy_func
 from .book_tools import Book, modifiedBook
-from jaseci.utils.utils import logger, perf_test_start, perf_test_stop
+from jaseci.utils.utils import logger, perf_test_start, perf_test_stop, find_first_api
+from jaseci import JsOrc
 
 session = None
 
@@ -25,7 +25,7 @@ def reset_state():
     global session
     session = {
         "filename": "js.session",
-        "user": [MetaService(run_svcs=False).build_super_master(name="admin")],
+        "user": [JsOrc.super_master(name="admin")],
         "mem-only": session["mem-only"] if session is not None else False,
         "connection": {"url": None, "token": None, "headers": None},
     }
@@ -83,17 +83,19 @@ def remote_api_call(payload, api_name):
     Constructs and issues call to remote server
     NOTE: Untested
     """
-    for i in SuperMaster.all_apis(None):
-        if api_name == "_".join(i["groups"]):
-            if i in SuperMaster._private_api:
-                path = "/js/" + api_name
-            elif i in SuperMaster._admin_api:
-                path = "/js_admin/" + api_name
-            elif i in SuperMaster._public_api:
-                path = "/js_public/" + api_name
-            break
-    ret = requests.post(
-        session["connection"]["url"] + path,
+    path, api = find_first_api(
+        api_name,
+        js_public=SuperMaster._public_api,
+        js=SuperMaster._private_api,
+        js_admin=SuperMaster._admin_api,
+    )
+
+    method = requests.post
+    if api["allowed_methods"] != None and "post" not in api["allowed_methods"]:
+        method = requests.get
+
+    ret = method(
+        session["connection"]["url"] + f"/{path}/{api_name}",
         json=payload,
         headers=session["connection"]["headers"],
     )
@@ -270,6 +272,36 @@ def login(url, username, password):
             pickle.dump(session, f)
 
 
+@click.command(help="Launch Jaseci Studio")
+def studio():
+    token = session["connection"]["token"]
+
+    if not token:
+        click.echo(
+            click.style(
+                "It doesn't look like you're logged in to a Jaseci instance. Please log in to a Jaseci instance to use this command.\n",
+                fg="red",
+            )
+        )
+    else:
+        url = session["connection"]["url"] + "/studio/"
+
+        if token == "PUBLIC":
+            click.echo(
+                click.style(
+                    "You are logged in as a public user. Please log in to a Jaseci instance to use this command.\n",
+                    fg="red",
+                )
+            )
+
+            webbrowser.open(url)
+        else:
+            click.echo(click.style("Launching Jaseci Studio...", fg="green"))
+            click.echo(click.style("URL: ", fg="green", bold=True) + url)
+            click.echo(click.style(f"Token: {token}", fg="green"))
+            webbrowser.open(url + "?token=" + token)
+
+
 @click.command(help="Command for unauthenticated log into live Jaseci server")
 @click.argument("url", type=str, required=True)
 def publogin(url):
@@ -408,6 +440,7 @@ jsctl.add_command(ls)
 jsctl.add_command(clear)
 jsctl.add_command(reset)
 jsctl.add_command(script)
+jsctl.add_command(studio)
 jsctl.add_command(booktool)
 cmd_tree_builder(extract_api_tree())
 cmd_tree_builder(extract_api_tree()["jac"], group_func=jac)

jaseci/jsctl/tests/test_jsctl.py

@@ -5,6 +5,9 @@ from click.testing import CliRunner
 import json
 import os
 
+from jaseci import JsOrc
+from jaseci.svc.redis_svc import RedisService
+
 
 class JsctlTest(TestCaseHelper, TestCase):
     """Unit tests for Jac language"""
@@ -15,6 +18,7 @@ class JsctlTest(TestCaseHelper, TestCase):
 
     def setUp(self):
         super().setUp()
+        JsOrc.svc("redis", RedisService).clear()
 
     def call(self, cmd: str):
         res = CliRunner(mix_stderr=False).invoke(jsctl.jsctl, ["-m"] + cmd.split())
@@ -154,6 +158,7 @@ class JsctlTest(TestCaseHelper, TestCase):
         r = self.call("config get APPLE -do_check False")
         self.assertEqual(r.strip(), "Grape2")
         r = self.call_cast("config list")
+
         self.assertEqual(len(r), 1)
 
     def test_jsctl_default_snt_setting(self):