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

jaseci/jsorc/manifests/redis.yaml

@@ -1,64 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: jaseci-redis
-  namespace: redis
-spec:
-  selector:
-    pod: jaseci-redis
-  ports:
-    - protocol: TCP
-      port: 6379
-      targetPort: 6379
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: jaseci-redis
-  namespace: redis
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      pod: jaseci-redis
-  template:
-    metadata:
-      labels:
-        pod: jaseci-redis
-    spec:
-      containers:
-        - name: jaseci-redis-master
-          image: redis
-          imagePullPolicy: IfNotPresent
-          command:
-            - redis-server
-            - "/redis-master/redis.conf"
-          resources:
-            limits:
-              cpu: "0.2"
-          ports:
-            - containerPort: 6379
-          volumeMounts:
-            - mountPath: /redis-master-data
-              name: data
-            - mountPath: /redis-master
-              name: config
-      volumes:
-        - name: data
-          emptyDir: {}
-        - name: config
-          configMap:
-            name: jaseci-redis-config
-            items:
-              - key: redis-config
-                path: redis.conf
----
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: jaseci-redis-config
-  namespace: redis
-data:
-  redis-config: |
-    maxmemory 1000mb
-    maxmemory-policy allkeys-lru

jaseci/jsorc/memory.py

@@ -1,258 +0,0 @@
-from json import dumps, loads
-import sys
-from jaseci.utils.file_handler import FileHandler
-from jaseci.utils.utils import find_class_and_import
-from jaseci.jsorc.jsorc import JsOrc
-
-
-@JsOrc.repository(name="hook")
-class MemoryHook:
-    """
-    Set of virtual functions to be used as hooks to allow access to
-    the complete set of items across jaseci object types. This class contains
-    a number of blank function calls to be bound extrenally and passed
-    to the objects. They return jaseci core types.
-    """
-
-    def __init__(self):
-        from jaseci.jsorc.live_actions import get_global_actions
-
-        self.mem = {"global": {}}
-        self._machine = None
-        self.save_obj_list = set()
-        self.save_glob_dict = {}
-        self.file_handlers = {}
-
-    ####################################################
-    #               COMMON GETTER/SETTER               #
-    ####################################################
-
-    # --------------------- OBJ ---------------------- #
-
-    def get_obj(self, caller_id, item_id, override=False):
-        """
-        Get item from session cache by id, then try store
-        TODO: May need to make this an object copy so you cant do mem writes
-        """
-        ret = self.get_obj_from_store(item_id)
-        if override or (ret is not None and ret.check_read_access(caller_id)):
-            return ret
-
-    def has_obj(self, item_id):
-        """
-        Checks for object existance
-        """
-        return self.has_obj_in_store(item_id)
-
-    def save_obj(self, caller_id, item, all_caches=False):
-        """Save item to session cache, then to store"""
-        if item.check_write_access(caller_id):
-            self.commit_obj_to_cache(item, all_caches=all_caches)
-            if item._persist:
-                self.save_obj_list.add(item)
-
-    def destroy_obj(self, caller_id, item):
-        """Destroy item from session cache then  store"""
-        if item.check_write_access(caller_id):
-            self.decommit_obj_from_cache(item)
-            if item._persist:
-                self.destroy_obj_from_store(item)
-
-    # --------------------- GLOB --------------------- #
-
-    def get_glob(self, name):
-        """
-        Get global config from session cache by id, then try store
-        """
-        return self.get_glob_from_store(name)
-
-    def has_glob(self, name):
-        """
-        Checks for global config existance
-        """
-        return self.has_glob_in_store(name)
-
-    def resolve_glob(self, name, default=None):
-        """
-        Util function for returning config if exists otherwise default
-        """
-        if self.has_glob(name):
-            return self.get_glob(name)
-        else:
-            return default
-
-    def save_glob(self, name, value, persist=True):
-        """Save global config to session cache, then to store"""
-        self.commit_glob_to_cache(name, value)
-
-        if persist:
-            self.save_glob_dict[name] = value
-
-    def list_glob(self):
-        """Lists all configs present"""
-        return self.list_glob_from_store()
-
-    def destroy_glob(self, name, persist=True):
-        """Destroy global config from session cache then store"""
-        self.decommit_glob_from_cache(name)
-
-        if persist:
-            self.destroy_glob_from_store(name)
-
-    # ----------------- SERVICE GLOB ----------------- #
-
-    def get_or_create_glob(self, name, val):
-        if not self.has_glob(name):
-            self.save_glob(name, dumps(val))
-            self.commit()
-        return loads(self.get_glob(name))
-
-    ####################################################
-    #        DATASOURCE METHOD (TO BE OVERRIDE)        #
-    ####################################################
-
-    # --------------------- OBJ ---------------------- #
-
-    def get_obj_from_store(self, item_id):
-        """
-        Get item from externally hooked general store by id
-        """
-        if item_id in self.mem:
-            return self.mem[item_id]
-
-        return None
-
-    def has_obj_in_store(self, item_id):
-        """
-        Checks for object existance in store
-        """
-        return item_id in self.mem
-
-    def destroy_obj_from_store(self, item):
-        """Destroy item to externally hooked general store"""
-        if item in self.save_obj_list:
-            self.save_obj_list.remove(item)
-
-    # --------------------- GLOB --------------------- #
-
-    def get_glob_from_store(self, name):
-        """
-        Get global config from externally hooked general store by name
-        """
-        if name in self.mem["global"]:
-            return self.mem["global"][name]
-
-        return None
-
-    def has_glob_in_store(self, name):
-        """
-        Checks for global config existance in store
-        """
-        return name in self.mem["global"]
-
-    def destroy_glob_from_store(self, name):
-        """Destroy global config to externally hooked general store"""
-        if name in self.save_glob_dict:
-            self.save_glob_dict.pop(name)
-
-    def list_glob_from_store(self):
-        """Get list of global config to externally hooked general store"""
-        return list(self.mem["global"].keys())
-
-    ####################################################
-    # ------------------ COMMITTER ------------------- #
-    ####################################################
-
-    def commit(self, skip_cache=False):
-        if not skip_cache:
-            for i in self.save_obj_list:
-                self.commit_obj_to_cache(i)
-
-            self.save_obj_list = set()
-
-            for i in self.save_glob_dict.keys():
-                self.commit_glob_to_cache(name=i, value=self.save_glob_dict[i])
-
-            self.save_glob_dict = {}
-
-    ###################################################
-    #   CACHE CONTROL (SHOULD NOT OVERRIDEN ON ORM)   #
-    ###################################################
-
-    # -------------------- GLOBS -------------------- #
-
-    def commit_glob_to_cache(self, name, value):
-        self.mem["global"][name] = value
-
-    def decommit_glob_from_cache(self, name):
-        self.mem["global"].pop(name)
-
-    # --------------------- OBJ --------------------- #
-
-    def has_id_in_mem_cache(self, id):
-        return id is not None and id in self.mem
-
-    def commit_obj_to_cache(self, item, all_caches=False):
-        self.mem[item.jid] = item
-
-    def commit_all_cache_sync(self):
-        for i in self.save_obj_list:
-            self.commit_obj_to_cache(i, all_caches=True)
-
-    def decommit_obj_from_cache(self, item):
-        self.mem.pop(item.jid)
-
-    ####################################################
-    # ------------------ UTILITIES ------------------- #
-    ####################################################
-
-    def get_object_distribution(self):
-        dist = {}
-        for i in self.mem.keys():
-            t = type(self.mem[i])
-            if t in dist.keys():
-                dist[t] += 1
-            else:
-                dist[t] = 1
-        return dist
-
-    def mem_size(self):
-        return sys.getsizeof(self.mem) / 1024
-
-    ###################################################
-    #                  CLASS CONTROL                  #
-    ###################################################
-
-    def find_class_and_import(self, j_type, mod):
-        cls = JsOrc.ctx_cls(j_type)
-
-        if not cls:
-            cls = find_class_and_import(j_type, mod)
-
-        return cls
-
-    def clear_cache(self, all=False):
-        MemoryHook.__init__(self)
-
-    ####################################################
-    #                   FILE HANDLER                   #
-    ####################################################
-
-    def add_file_handler(self, file_handler: FileHandler) -> str:
-        self.file_handlers.update({file_handler.id: file_handler})
-        return file_handler.id
-
-    def get_file_handler(self, file_id: str):
-        return self.file_handlers.get(file_id, None)
-
-    def pop_file_handler(self, file_id: str):
-        return self.file_handlers.pop(file_id, None)
-
-    def clean_file_handler(self):
-        for file_handler in list(self.file_handlers.values()):
-            self.file_handlers.pop(file_handler.id, None)
-            if not file_handler.persist:
-                file_handler.delete()
-
-    def __del__(self):
-        self.clean_file_handler()

jaseci/jsorc/redis.py

@@ -1,139 +0,0 @@
-"""
-This module includes code related to hooking Jaseci's Redis to the
-core engine.
-"""
-import json
-
-import jaseci as core_mod
-from jaseci.utils.json_handler import JaseciJsonDecoder, jsci_dict_normalize
-from jaseci.jsorc.memory import MemoryHook
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.extens.svc.redis_svc import RedisService
-
-
-#################################################
-#                  REDIS HOOK                   #
-#################################################
-
-
-@JsOrc.repository(name="hook", priority=1)
-class RedisHook(MemoryHook):
-    def __init__(self, redis: RedisService = None):
-        self.redis = JsOrc.svc("redis", RedisService)
-        self.red_touch_count = 0
-
-        super().__init__()
-
-    ####################################################
-    #        DATASOURCE METHOD (TO BE OVERRIDE)        #
-    ####################################################
-
-    # --------------------- OBJ ---------------------- #
-
-    def get_obj_from_store(self, item_id):
-        """
-        Get item from externally hooked general store by id
-        """
-        obj = super().get_obj_from_store(item_id)
-
-        if obj is None and self.redis.is_running():
-            loaded_obj = self.redis.get(item_id)
-            if loaded_obj:
-                self.red_touch_count += 1
-                jdict = json.loads(loaded_obj, cls=JaseciJsonDecoder)
-                j_type = jdict["j_type"]
-                j_master = jdict["j_master"]
-                class_for_type = self.find_class_and_import(j_type, core_mod)
-                ret_obj = class_for_type(h=self, m_id=j_master, auto_save=False)
-                jsci_dict_normalize(jdict, parent_obj=ret_obj)
-                ret_obj.dict_load(jdict)
-
-                super().commit_obj_to_cache(ret_obj)
-                obj = ret_obj
-        if obj:
-            obj._persist = True
-        return obj
-
-    def has_obj_in_store(self, item_id):
-        """
-        Checks for object existance in store
-        """
-        return super().has_obj_in_store(item_id) or (
-            self.redis.is_running() and self.redis.exists(item_id)
-        )
-
-    # --------------------- GLOB --------------------- #
-
-    def get_glob_from_store(self, name):
-        """
-        Get global config from externally hooked general store by name
-        """
-        glob = super().get_glob_from_store(name)
-
-        if glob is None and self.redis.is_running():
-            glob = self.redis.hget("global", name)
-
-            if glob:
-                self.red_touch_count += 1
-                super().commit_glob_to_cache(name, glob)
-
-        return glob
-
-    def has_glob_in_store(self, name):
-        """
-        Checks for global config existance in store
-        """
-        return super().has_glob_in_store(name) or (
-            self.redis.is_running() and self.redis.hexists("global", name)
-        )
-
-    def list_glob_from_store(self):
-        """Get list of global config to externally hooked general store"""
-        globs = super().list_glob_from_store()
-
-        if not globs and self.redis.is_running():
-            globs = self.redis.hkeys("global")
-
-        return globs
-
-    ###################################################
-    #   CACHE CONTROL (SHOULD NOT OVERRIDEN ON ORM)   #
-    ###################################################
-
-    # -------------------- GLOBS -------------------- #
-
-    def commit_glob_to_cache(self, name, value):
-        super().commit_glob_to_cache(name, value)
-        if self.redis.is_running():
-            self.redis.hset("global", name, value)
-
-    def decommit_glob_from_cache(self, name):
-        super().decommit_glob_from_cache(name)
-
-        if self.redis.is_running():
-            self.redis.hdel("global", name)
-
-    # --------------------- OBJ --------------------- #
-
-    def commit_obj_to_cache(self, item, all_caches=False):
-        super().commit_obj_to_cache(item)
-
-        if all_caches and item._persist and self.redis.is_running():
-            self.redis.set(item.jid, item.json(detailed=True))
-
-    def decommit_obj_from_cache(self, item):
-        super().decommit_obj_from_cache(item)
-
-        if item._persist and self.redis.is_running():
-            self.redis.delete(item.jid)
-
-    ###################################################
-    #                     CLEANER                     #
-    ###################################################
-
-    def clear_cache(self, all=False):
-        super().clear_cache(all)
-        self.redis.clear(all)
-
-
-# ----------------------------------------------- #

jaseci/jsorc/remote_actions.py

@@ -1,157 +0,0 @@
-"""
-General action base class with automation for hot loading
-"""
-from jaseci.utils.utils import logger, ColCodes as Cc
-from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
-from pydantic import validate_arguments
-from time import time
-import inspect
-import uvicorn
-import os
-import re
-
-var_args = re.compile(r"^\*[^\*]")
-var_kwargs = re.compile(r"^\*\*[^\*]")
-
-args_kwargs = (2, 4)
-remote_actions = {}
-registered_apis = []
-registered_endpoints = []
-ACTIONS_SPEC_LOC = "/jaseci_actions_spec/"
-JS_ACTION_PREAMBLE = "js_action_"
-JS_ENDPOINT_PREAMBLE = "js_endpoint_"
-
-
-def mark_as_remote(api):
-    registered_apis.append(api)
-
-
-def mark_as_endpoint(endpoint):
-    registered_endpoints.append(endpoint)
-
-
-def serv_actions():
-    """Returns fastAPI app interface for actions"""
-    app = FastAPI(
-        title="Jaseci Action Set API",
-        description="A Jaseci Action Set",
-    )
-
-    @app.get("/")
-    def home_redirect():
-        return RedirectResponse(url="/docs")
-
-    @app.get(ACTIONS_SPEC_LOC)
-    def action_list():
-        return remote_actions
-
-    for i in registered_apis:
-        gen_api_service(app, *i)
-    for i in registered_endpoints:
-        gen_endpoint(app, *i)
-    return app
-
-
-def gen_api_service(app, func, act_group, aliases, caller_globals):
-    """Helper for jaseci_action decorator"""
-    # Construct list of action apis available
-    act_group = (
-        [os.path.basename(inspect.getfile(func)).split(".")[0]]
-        if act_group is None
-        else act_group
-    )
-    varnames = []
-    for param in inspect.signature(func).parameters.values():
-        varnames.append(str(param) if param.kind in args_kwargs else param.name)
-
-    remote_actions[f"{'.'.join(act_group+[func.__name__])}"] = varnames
-
-    # Need to get pydatic model for func signature for fastAPI post
-    model = validate_arguments(func).model
-
-    # Keep only fields present in param list in base model
-    keep_fields = {}
-    for name in varnames:
-        if var_args.match(name):
-            keep_fields[name] = model.__fields__[name[1:]]
-            keep_fields[name].name = name
-            keep_fields[name].alias = name
-        elif var_kwargs.match(name):
-            keep_fields[name] = model.__fields__[name[2:]]
-            keep_fields[name].name = name
-            keep_fields[name].alias = name
-        else:
-            field = model.__fields__.get(name)
-            if field:
-                keep_fields[name] = field
-    model.__fields__ = keep_fields
-
-    # Create duplicate funtion for api endpoint and inject in call site globals
-    @app.post(f"/{func.__name__}/")
-    def new_func(params: model = model.construct()):
-        params: dict = params.__dict__
-        pl_peek = str(params)[:128]
-        logger.info(str(f"Incoming call to {func.__name__} with {pl_peek}"))
-        start_time = time()
-
-        args = []
-        kwargs = {}
-        fp1 = inspect.signature(func).parameters.values()
-        fp2 = list(fp1)
-
-        # try to process args
-        for param in fp1:
-            _param = str(param) if param.kind in args_kwargs else param.name
-            if _param in params:
-                fp2.remove(param)
-                if var_args.match(_param):
-                    for arg in params.get(_param) or []:
-                        args.append(arg)
-                    break
-                elif var_kwargs.match(_param):
-                    kwargs.update(params.get(_param) or {})
-                    break
-                args.append(params.get(_param))
-            else:
-                break
-
-        # try to process kwargs
-        for param in fp2:
-            param = str(param) if param.kind in args_kwargs else param.name
-            if param in params:
-                if var_kwargs.match(param):
-                    kwargs.update(params.get(param) or {})
-                    break
-                kwargs[param] = params.get(param)
-            else:
-                break
-
-        ret = validate_arguments(func)(*args, **kwargs)
-        tot_time = time() - start_time
-        logger.info(
-            str(
-                f"API call to {Cc.TG}{func.__name__}{Cc.EC}"
-                f" completed in {Cc.TY}{tot_time:.3f} seconds{Cc.EC}"
-            )
-        )
-        return ret
-
-    if func.__name__ == "setup":
-        new_func = app.on_event("startup")(new_func)
-    for i in aliases:
-        new_func = app.post(f"/{i}/")(new_func)
-        remote_actions[f"{'.'.join(act_group+[i])}"] = varnames
-    caller_globals[f"{JS_ACTION_PREAMBLE}{func.__name__}"] = new_func
-
-
-def gen_endpoint(app, func, endpoint, mount, caller_globals):
-    """Helper for jaseci_action decorator"""
-    # Create duplicate funtion for api endpoint and inject in call site globals
-    if mount is not None:
-        app.mount(*mount)
-    caller_globals[f"{JS_ENDPOINT_PREAMBLE}{func.__name__}"] = app.get(endpoint)(func)
-
-
-def launch_server(port=80, host="0.0.0.0"):
-    uvicorn.run(serv_actions(), port=port, host=host)