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

jaseci/VERSION

@@ -1 +1 @@
-1.4.0.9
+1.4.0.11

jaseci/__init__.py

@@ -1,4 +1,6 @@
 from os.path import dirname, join
+from .jsorc_settings import JsOrcSettings
+from .jsorc import State, JsOrc
 
 
 def get_ver():
@@ -9,6 +11,7 @@ def get_ver():
 __version__ = get_ver()
 __creator__ = "Jason Mars and friends"
 __url__ = "https://jaseci.org"
+__all__ = ["State", "JsOrc", "JsOrcSettings"]
 
 
 def load_standard():

jaseci/actions/standard/elastic.py

@@ -1,9 +1,10 @@
 from jaseci.actions.live_actions import jaseci_action
-from jaseci.svc import MetaService
+from jaseci import JsOrc
+from jaseci.svc.elastic_svc import ElasticService, Elastic
 
 
 def elastic():
-    return MetaService().get_service("elastic").poke()
+    return JsOrc.svc("elastic", ElasticService).poke(Elastic)
 
 
 @jaseci_action()

jaseci/actions/standard/mail.py

@@ -1,9 +1,10 @@
 from jaseci.actions.live_actions import jaseci_action
-from jaseci.svc import MetaService
+from jaseci import JsOrc
+from jaseci.svc.mail_svc import Mailer
 
 
 @jaseci_action()
 def send(sender, recipients, subject, text, html):
-    MetaService().get_service("mail").poke().send_custom_email(
+    JsOrc.svc("mail").poke(Mailer).send_custom_email(
         sender, recipients, subject, (text, html)
     )

jaseci/actions/standard/std.py

@@ -6,7 +6,8 @@ from jaseci.jac.machine.jac_value import jac_wrap_value as jwv
 from jaseci.actions.live_actions import jaseci_action
 from jaseci.utils.utils import master_from_meta
 from jaseci.element.element import Element
-from jaseci.svc import MetaService
+from jaseci import JsOrc
+from jaseci.svc.elastic_svc import Elastic
 
 import sys
 import json
@@ -214,7 +215,7 @@ def clear_report(meta):
 def log_activity(
     log: dict, action: str = "", query: str = "", suffix: str = "", meta: dict = {}
 ):
-    elastic = MetaService().get_service("elastic").poke()
+    elastic = JsOrc.svc("elastic").poke(Elastic)
     activity = elastic.generate_from_meta(meta, log)
 
     return elastic.doc_activity(activity, query, suffix)

jaseci/actions/standard/stripe.py

@@ -1,13 +1,14 @@
 """Built in actions for Jaseci"""
 import stripe as s
 
-from jaseci.svc import MetaService
+from jaseci import JsOrc
+from jaseci.svc.stripe_svc import StripeService
 from datetime import datetime
 from jaseci.actions.live_actions import jaseci_action
 
 
 def stripe() -> s:
-    return MetaService().get_service("stripe").poke()
+    return JsOrc.svc("stripe", StripeService).poke()
 
 
 @jaseci_action()

jaseci/actions/standard/task.py

@@ -1,5 +1,7 @@
 """Built in actions for Jaseci"""
+from jaseci import JsOrc
 from jaseci.actions.live_actions import jaseci_action
+from jaseci.svc.task_svc import TaskService
 
 
 @jaseci_action()
@@ -7,9 +9,5 @@ def get_result(task_id, wait, meta):
     """
     Get task result by task_id
     """
-    task = meta["h"].task
 
-    if not task.is_running():
-        raise Exception("Task hook is not yet initialized!")
-
-    return task.get_by_task_id(task_id, wait)
+    return JsOrc.svc("task").poke(TaskService).get_by_task_id(task_id, wait)

jaseci/actions/standard/tests/test_mail_lib.py

@@ -1,7 +1,7 @@
 from unittest.mock import MagicMock, Mock
 
-from jaseci.svc import MailService
-from jaseci.svc.mail import MAIL_CONFIG
+from jaseci import JsOrc
+from jaseci.svc.mail_svc import MailService
 from jaseci.utils.test_core import CoreTest
 
 
@@ -11,22 +11,23 @@ class MailLibTest(CoreTest):
     fixture_src = __file__
 
     def __init__(self, *args, **kwargs):
-        MAIL_CONFIG["enabled"] = True
+        JsOrc.settings("MAIL_CONFIG")["enabled"] = True
         MailService.connect = MagicMock(return_value=Mock())
         super(MailLibTest, self).__init__(*args, **kwargs)
 
     def setUp(self):
-        super().setUp(True)
+        super().setUp()
 
-    def test_send_mail(self):
+    @JsOrc.inject(services=["mail"])
+    def test_send_mail(self, mail: MailService):
         self.call(
             self.mast,
             ["sentinel_register", {"code": self.load_jac("mail_test.jac")}],
         )
         ret = self.call(self.mast, ["walker_run", {"name": "send_mail"}])
         self.assertTrue(ret["success"])
-        self.assertTrue(self.mast._h.mail.connect.called)
+        self.assertTrue(mail.connect.called)
         self.assertEqual(
-            self.mast._h.mail.app.method_calls[0].args,
+            mail.app.method_calls[0].args,
             (None, ["jaseci.dev@gmail.com"], "Test Subject", ("Test", "<h1>Test</h1>")),
         )

jaseci/actions/tests/test_std.py

@@ -3,7 +3,7 @@ from unittest import TestCase
 import jaseci.actions.tests.std_test_code as stc
 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
 
 
@@ -12,13 +12,12 @@ class JacTests(TestCaseHelper, TestCase):
 
     def setUp(self):
         super().setUp()
-        self.meta = MetaService()
 
     def tearDown(self):
         super().tearDown()
 
     def test_rand_std(self):
-        sent = Sentinel(m_id=0, h=self.meta.build_hook())
+        sent = Sentinel(m_id=0, h=JsOrc.hook())
         gph = Graph(m_id=0, h=sent._h)
         sent.register_code(stc.rand_std)
         test_walker = sent.run_architype("init")
@@ -31,7 +30,7 @@ class JacTests(TestCaseHelper, TestCase):
         self.assertGreater(len(report[3]), len(report[2]))
 
     def test_file_io(self):
-        sent = Sentinel(m_id=0, h=self.meta.build_hook())
+        sent = Sentinel(m_id=0, h=JsOrc.hook())
         gph = Graph(m_id=0, h=sent._h)
         sent.register_code(stc.file_io)
         test_walker = sent.run_architype("init")
@@ -41,7 +40,7 @@ class JacTests(TestCaseHelper, TestCase):
         self.assertEqual(report, ['{"a": 10}{"a": 10}'])
 
     def test_std_used_in_node_has_var(self):
-        sent = Sentinel(m_id=0, h=self.meta.build_hook())
+        sent = Sentinel(m_id=0, h=JsOrc.hook())
         gph = Graph(m_id=0, h=sent._h)
         sent.register_code(stc.std_used_in_node_has_var)
         test_walker = sent.run_architype("init")

jaseci/actor/walker.py

@@ -20,6 +20,9 @@ from jaseci.jac.interpreter.walker_interp import WalkerInterp
 import uuid
 import hashlib
 
+from jaseci import JsOrc
+from jaseci.svc.task_svc import TaskService
+
 
 class Walker(Element, WalkerInterp, Anchored):
     """Walker class for Jaseci"""
@@ -130,7 +133,7 @@ class Walker(Element, WalkerInterp, Anchored):
 
     def run(self, start_node=None, prime_ctx=None, request_ctx=None, profiling=False):
         """Executes Walker to completion"""
-        if self.for_queue() and self._h.task.is_running():
+        if self.for_queue() and JsOrc.svc("task").is_running():
             start_node = (
                 start_node
                 if not (start_node is None)
@@ -143,7 +146,7 @@ class Walker(Element, WalkerInterp, Anchored):
 
             return {
                 "is_queued": True,
-                "result": self._h.task.add_queue(
+                "result": JsOrc.svc("task", TaskService).add_queue(
                     self,
                     start_node,
                     prime_ctx or self.context,
@@ -228,7 +231,7 @@ class Walker(Element, WalkerInterp, Anchored):
         """
         Destroys self from memory and persistent storage
         """
-        if not self.for_queue() or not self._h.task.is_running():
+        if not self.for_queue() or not JsOrc.svc("task").is_running():
             WalkerInterp.destroy(self)
             super().destroy()
 

jaseci/api/config_api.py

@@ -20,10 +20,11 @@ class ConfigApi:
             "REDIS_CONFIG",
             "TASK_CONFIG",
             "MAIL_CONFIG",
-            "PROMON_CONFIG",
+            "PROME_CONFIG",
             "ELASTIC_CONFIG",
             "STRIPE_CONFIG",
-            "META_CONFIG",
+            "KUBE_CONFIG",
+            "JSORC_CONFIG",
         ]
 
     @Interface.admin_api(cli_args=["name"])

jaseci/api/jac_api.py

@@ -6,7 +6,7 @@ import json
 import os
 
 from jaseci.api.interface import Interface
-from jaseci.svc import MetaService
+from jaseci import JsOrc
 
 
 class JacApi:
@@ -158,7 +158,7 @@ class JacApi:
         return faux.graph_get(nd=faux.active_gph(), mode="dot", detailed=detailed)
 
     def faux_master(self):
-        faux = MetaService(run_svcs=False).build_super_master()
+        faux = JsOrc.super_master()
         faux._h.mem["global"] = deepcopy(self._h.mem["global"])
         return faux
 

jaseci/api/jsorc_api.py

@@ -7,8 +7,12 @@ import json
 from json import dumps, loads
 from time import time
 from base64 import b64decode
-from jaseci.svc import CommonService
-from jaseci.svc.common import Kube, UNSAFE_PARAPHRASE
+
+from jaseci import JsOrc
+from jaseci.utils.utils import logger
+from jaseci.svc.kube_svc import KubeService
+from jaseci.utils.actions.actions_manager import ActionManager
+
 from jaseci.api.interface import Interface
 
 
@@ -18,27 +22,28 @@ class JsOrcApi:
     """
 
     @Interface.admin_api()
-    def load_yaml(self, files: list, namespace: str = "default"):
+    def load_yaml(self, files: list, namespace: str = None):
         """
         applying list of yaml files without associating to any modules/services
         """
 
-        if self._h.meta.is_automated():
-            kube = self._h.meta.app.kubernetes
-            kube: Kube
+        try:
+            kube = JsOrc.svc("kube").poke(KubeService)
 
             res = {}
-
             for file in files:
                 for conf in yaml.safe_load_all(b64decode(file["base64"])):
                     kind = conf["kind"]
-                    kube.create(kind, namespace, conf)
+                    kube.create(
+                        kind, conf["metadata"]["name"], conf, namespace=namespace
+                    )
                     if not res.get(kind):
                         res[kind] = []
                     res[kind].append(conf)
 
             return res
-        else:
+        except Exception:
+            logger.exception("Error loading yaml!")
             return {"message": "load_yaml is not supported on non automated JsOrc!"}
 
     @Interface.admin_api(cli_args=["name"])
@@ -64,16 +69,16 @@ class JsOrcApi:
         old_config = self._h.get_glob(name)
         if old_config:
             old_config = loads(old_config)
-            old_config.pop("__OLD_CONFIG__", None)
+            old_config.pop("__OLD_CONFIG__", {})
             for kind, confs in old_config.items():
-                names = []
+                _confs = {}
                 for conf in confs:
-                    names.append(conf["metadata"]["name"])
-                old_config[kind] = names
+                    _confs.update({conf["metadata"]["name"]: conf})
+                old_config[kind] = _confs
 
             new_config["__OLD_CONFIG__"] = old_config
 
-            if unsafe_paraphrase == UNSAFE_PARAPHRASE:
+            if unsafe_paraphrase == JsOrc.settings("UNSAFE_PARAPHRASE"):
                 new_config["__UNSAFE_PARAPHRASE__"] = unsafe_paraphrase
 
         self._h.save_glob(name, dumps(new_config))
@@ -86,23 +91,10 @@ class JsOrcApi:
         refreshing service's config. If JsOrc is not automated, service will restart else JsOrc will handle the rest
         """
 
-        hook = self._h
-
-        to_start = not hook.meta.is_automated()
+        # will throw exception if not existing
+        JsOrc.svc_reset(name)
 
-        service = getattr(hook, name, None)
-
-        response = {"success": False}
-
-        if isinstance(service, CommonService):
-            service.reset(hook, to_start)
-            response["success"] = True
-        else:
-            response[
-                "message"
-            ] = f"{name} is not a valid service. Can not refresh config."
-
-        return response
+        return {"success": True}
 
     @Interface.admin_api(cli_args=["name"])
     def service_call(self, svc: str, attrs: list = []):
@@ -110,12 +102,7 @@ class JsOrcApi:
         temporary api for retreiving/calling attributes of specific instance.
         """
 
-        from jaseci.svc import MetaService
-
-        meta = self._h.meta
-        meta: MetaService
-
-        svc = meta.get_service(svc)
+        svc = JsOrc.svc(svc)
 
         if not svc:
             return "Service (svc) field is required!"
@@ -148,25 +135,19 @@ class JsOrcApi:
         JSORC will load the corresponding module or start a microservice if needed.
         Return the current status of the action.
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            hook.meta.app.load_actions(name, mode)
-            status = hook.meta.app.get_actions_status(name)
-            return {"success": True, "action_status": status}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        action_manager = JsOrc.get("action_manager", ActionManager)
+        action_manager.load_actions(name, mode)
+        status = action_manager.get_actions_status(name)
+
+        return {"success": True, "action_status": status}
 
     @Interface.admin_api(cli_args=["name"])
     def jsorc_actions_status(self, name: str):
         """
         Get the current status of an action
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            status = hook.meta.app.get_actions_status(name)
-            return {"success": True, "action_status": status}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        status = JsOrc.get("action_manager", ActionManager).get_actions_status(name)
+        return {"success": True, "action_status": status}
 
     @Interface.admin_api(cli_args=["name"])
     def jsorc_actions_unload(
@@ -176,12 +157,10 @@ class JsOrcApi:
         Unload an action through JSORC.
         If retire_svc is set to True (true by default), it will also retire the corresponding microservice.
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            res = hook.meta.app.unload_actions(name, mode, retire_svc)
-            return {"success": res[0], "message": res[1]}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        res = JsOrc.get("action_manager", ActionManager).unload_actions(
+            name, mode, retire_svc
+        )
+        return {"success": res[0], "message": res[1]}
 
     @Interface.admin_api(cli_args=["config", "name"])
     def jsorc_actions_config(self, config: str, name: str):
@@ -190,133 +169,93 @@ class JsOrcApi:
         config: name of the ai kit package (e.g. jac_nlp.config, jac_vision.config)
         name: name of the action module (e.g. use_enc, bi_enc)
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            res = hook.meta.app.load_action_config(config, name)
-            return {"success": res}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        res = JsOrc.get("action_manager", ActionManager).load_action_config(
+            config, name
+        )
+        return {"success": res}
 
     @Interface.admin_api()
     def jsorc_trackact_start(self):
         """ "
         Instruct JSORC to start tracking any changes in actions state
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            hook.meta.app.actions_tracking_start()
-            return {"success": True}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        JsOrc.get("action_manager", ActionManager).actions_tracking_start()
+        return {"success": True}
 
     @Interface.admin_api()
     def jsorc_trackact_stop(self):
         """ "
         Instruct JSORC to start tracking any changes in actions state
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.meta.app.actions_tracking_stop()
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        return JsOrc.get("action_manager", ActionManager).actions_tracking_stop()
 
     @Interface.admin_api()
     def jsorc_benchmark_start(self):
         """
         Tell JSORC to start collecting request performance metrics
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            hook.meta.app.benchmark_start()
-            return {"success": True}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        JsOrc.get("action_manager", ActionManager).benchmark_start()
+        return {"success": True}
 
     @Interface.admin_api()
     def jsorc_benchmark_report(self):
         """
         Report the collected request performance metrics of the currently ongoing benchmark
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.meta.app.benchmark_report()
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        return JsOrc.get("action_manager", ActionManager).benchmark_report()
 
     @Interface.admin_api()
     def jsorc_benchmark_stop(self, report: bool = True):
         """
         End the benchmark period and report performance metrics
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.meta.app.benchmark_stop(report)
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        return JsOrc.get("action_manager", ActionManager).benchmark_stop(report)
 
     @Interface.admin_api()
     def jsorc_tracksys_start(self):
         """
         Ask JSORC to start tracking the state of the system as observed by JSORC on every interval.
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            hook.meta.app.state_tracking_start()
-            return {"success": True}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        JsOrc.get("action_manager", ActionManager).state_tracking_start()
+        return {"success": True}
 
     @Interface.admin_api()
     def jsorc_tracksys_report(self):
         """
         Report the tracked system states so far
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.meta.app.state_tracking_report()
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        return JsOrc.get("action_manager", ActionManager).state_tracking_report()
 
     @Interface.admin_api()
     def jsorc_tracksys_stop(self):
         """
         Stop state tracking for JSORC
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.meta.app.state_tracking_stop()
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        return JsOrc.get("action_manager", ActionManager).state_tracking_stop()
 
     @Interface.admin_api()
     def jsorc_actionpolicy_set(self, policy_name: str, policy_params: dict = {}):
         """
         Set an action optimization policy for JSORC
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            res = hook.meta.app.set_action_policy(policy_name, policy_params)
-            if res is True:
-                return {
-                    "success": True,
-                    "message": f"Action optimization policy configured as {policy_name} with params {policy_params}",
-                }
-            else:
-                return {"success": False, "message": res}
+        res = JsOrc.get("action_manager", ActionManager).set_action_policy(
+            policy_name, policy_params
+        )
+        if res is True:
+            return {
+                "success": True,
+                "message": f"Action optimization policy configured as {policy_name} with params {policy_params}",
+            }
         else:
-            return {"success": False, "message": "No running JSORC service."}
+            return {"success": False, "message": res}
 
     @Interface.admin_api()
     def jsorc_actionpolicy_get(self):
         """
         Get the current active action optimization policy
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            policy = hook.meta.app.get_action_policy()
-            return {"success": True, "policy": policy}
-        else:
-            return {"success": False, "message": "No running JSORC service."}
+        policy = JsOrc.get("action_manager", ActionManager).get_action_policy()
+        return {"success": True, "policy": policy}
 
     @Interface.admin_api()
     def jsorc_loadtest(self, test: str, experiment: str = "", mem: int = 0):

jaseci/api/prometheus_api.py

@@ -2,6 +2,12 @@
 Prometheus APIs
 """
 from jaseci.api.interface import Interface
+from jaseci import JsOrc
+from jaseci.svc.prome_svc import PrometheusService
+
+
+def prome():
+    return JsOrc.svc("prome").poke(PrometheusService)
 
 
 class PrometheusApi:
@@ -14,22 +20,14 @@ class PrometheusApi:
         """
         Return list of availabel metrics
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.promon.all_metrics()
-        else:
-            return {"success": False, "message": "No runnning Prometheus service."}
+        return prome().all_metrics()
 
     @Interface.admin_api()
     def prometheus_pod_list(self, namespace: str = "", exclude_prom: bool = False):
         """
         Return list of pods. If exclude_prom,
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.promon.pods(namespace=namespace, exclude_prom=exclude_prom)
-        else:
-            return {"success": False, "message": "No runnning Prometheus service."}
+        return prome().pods(namespace=namespace, exclude_prom=exclude_prom)
 
     @Interface.admin_api()
     def prometheus_pod_info(
@@ -42,13 +40,9 @@ class PrometheusApi:
         """
         Return pods info and metrics
         """
-        hook = self._h
-        if hook.meta.run_svcs:
-            return hook.promon.info(
-                namespace=namespace,
-                exclude_prom=exclude_prom,
-                timestamp=timestamp,
-                duration=duration,
-            )
-        else:
-            return {"success": False, "message": "No runnning Prometheus service."}
+        return prome().info(
+            namespace=namespace,
+            exclude_prom=exclude_prom,
+            timestamp=timestamp,
+            duration=duration,
+        )