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

jaseci/extens/act_lib/elastic.py

@@ -1,87 +0,0 @@
-from jaseci.jsorc.live_actions import jaseci_action
-from jaseci.jsorc.jsorc import JsOrc
-from jaseci.extens.svc.elastic_svc import ElasticService, Elastic
-
-
-def elastic():
-    return JsOrc.svc("elastic", ElasticService).poke(Elastic)
-
-
-@jaseci_action()
-def _post(url: str, json: dict = {}):
-    return elastic()._post(url, json)
-
-
-@jaseci_action()
-def _get(url: str, json: dict = None):
-    return elastic()._get(url, json)
-
-
-@jaseci_action()
-def post(url: str, body: dict, index: str = "", suffix: str = ""):
-    return elastic().post(url, body, index, suffix)
-
-
-@jaseci_action()
-def post_act(url: str, body: dict, suffix: str = ""):
-    return elastic().post_act(url, body, suffix)
-
-
-@jaseci_action()
-def get(url: str, body: dict, index: str = "", suffix: str = ""):
-    return elastic().get(url, body, index)
-
-
-@jaseci_action()
-def get_act(url: str, body: dict, suffix: str = ""):
-    return elastic().get_act(url, body, suffix)
-
-
-@jaseci_action()
-def doc(log: dict, query: str = "", index: str = "", suffix: str = ""):
-    return elastic().doc(log, query, index, suffix)
-
-
-@jaseci_action()
-def doc_activity(log: dict, query: str = "", suffix: str = ""):
-    return elastic().doc_activity(log, query, suffix)
-
-
-@jaseci_action()
-def search(body: dict, query: str = "", index: str = "", suffix: str = ""):
-    return elastic().search(body, query, index, suffix)
-
-
-@jaseci_action()
-def search_activity(body: dict, query: str = "", suffix: str = ""):
-    return elastic().search_activity(body, query, suffix)
-
-
-@jaseci_action()
-def mapping(query: str = "", index: str = "", suffix: str = ""):
-    return elastic().mapping(query, index, suffix)
-
-
-@jaseci_action()
-def mapping_activity(query: str = "", suffix: str = ""):
-    return elastic().mapping_activity(query, suffix)
-
-
-@jaseci_action()
-def refresh(index: str = "", suffix: str = ""):
-    return elastic().refresh(index, suffix)
-
-
-@jaseci_action()
-def refresh_activity(suffix: str = ""):
-    return elastic().refresh_activity(suffix)
-
-
-@jaseci_action()
-def aliases(query: str = "pretty=true"):
-    return elastic().aliases(query)
-
-
-@jaseci_action()
-def reindex(body: dict, query: str = "pretty"):
-    return elastic().reindex(body, query)

jaseci/extens/act_lib/file.py

@@ -1,77 +0,0 @@
-"""Built in actions for Jaseci"""
-
-from jaseci.jsorc.live_actions import jaseci_action
-import os
-import json
-import base64
-
-
-@jaseci_action()
-def load_str(fn: str, max_chars: int = None):
-    """Standard built in for loading from file to string"""
-    with open(fn, "r") as file:
-        data = file.read(max_chars)
-    return data
-
-
-@jaseci_action()
-def load_json(fn: str):
-    """Standard built in for loading json from file to dictionary"""
-    with open(fn, "r") as file:
-        data = json.load(file)
-    return data
-
-
-@jaseci_action()
-def load_to_b64(fn: str):
-    """Standard built in for loading binary from file to base64"""
-    with open(fn, "rb") as file:
-        data = base64.b64encode(file.read()).decode("ascii")
-    return data
-
-
-@jaseci_action()
-def dump_str(fn: str, s: str):
-    """Standard built in for dumping to file from string"""
-    with open(fn, "w") as file:
-        num_chars = file.write(s)
-    return num_chars
-
-
-@jaseci_action()
-def dump_json(fn: str, obj, indent: int = None):
-    """Standard built in for dumping json to file from dictionary"""
-    with open(fn, "w") as file:
-        json.dump(obj, file, indent=indent)
-
-
-@jaseci_action()
-def dump_from_b64(fn: str, b64: str):
-    """Standard built in for dumping binary to file from from base64"""
-    with open(fn, "wb") as file:
-        file.write(base64.b64decode(b64.encode("ascii")))
-
-
-@jaseci_action()
-def append_str(fn: str, s: str):
-    """Standard built in for appending to file from string"""
-    with open(fn, "a") as file:
-        num_chars = file.write(s)
-    return num_chars
-
-
-@jaseci_action()
-def append_from_b64(fn: str, b64: str):
-    """Standard built in for appending binary to file from from base64"""
-    with open(fn, "ab") as file:
-        file.write(base64.b64decode(b64.encode("ascii")))
-
-
-@jaseci_action()
-def delete(fn: str):
-    """Standard built in for deleting a file"""
-    if os.path.exists(fn):
-        os.remove(fn)
-        return True
-    else:
-        return False

jaseci/extens/act_lib/file_handler.py

@@ -1,190 +0,0 @@
-"""Built in actions for Jaseci"""
-
-import mimetypes
-import magic
-from os import path
-from urllib.parse import urlparse
-from requests import get
-from jaseci.jsorc.live_actions import jaseci_action
-
-
-@jaseci_action(act_group=["fh"])
-def load(path: str, meta: dict = {}):
-    """temp"""
-    from jaseci.utils.file_handler import FileHandler
-
-    return meta["h"].add_file_handler(FileHandler.fromPath(path))
-
-
-@jaseci_action(act_group=["fh"])
-def new(
-    name: str,
-    content_type: str = None,
-    field: str = None,
-    persist: bool = False,
-    meta: dict = {},
-):
-    """temp"""
-    from jaseci.utils.file_handler import FileHandler
-
-    return meta["h"].add_file_handler(
-        FileHandler(name=name, content_type=content_type, field=field, persist=persist)
-    )
-
-
-@jaseci_action
-def guess_type(filename: str) -> tuple:
-    """temp"""
-    return mimetypes.guess_type(filename)
-
-
-@jaseci_action(act_group=["fh"])
-def update(
-    id: str,
-    name: str = None,
-    content_type: str = None,
-    field: str = None,
-    persist: bool = None,
-    meta: dict = {},
-):
-    """temp"""
-    from jaseci.utils.file_handler import FileHandler
-
-    file_handler: FileHandler = meta["h"].get_file_handler(id)
-    if name:
-        file_handler.name = name
-        if not content_type:
-            file_handler.content_type = mimetypes.guess_type(name)[0]
-
-    if content_type:
-        file_handler.content_type = content_type
-
-    if field:
-        file_handler.field = field
-
-    if persist != None:
-        file_handler.persist = persist
-
-    return file_handler.attr()
-
-
-@jaseci_action(act_group=["fh"])
-def read(
-    id: str, offset: int = None, mode: str = "r", encoding: str = None, meta: dict = {}
-):
-    """temp"""
-    return meta["h"].get_file_handler(id).read(offset, mode, encoding)
-
-
-@jaseci_action(act_group=["fh"])
-def seek(id: str, offset: int, whence: int = 0, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).seek(offset, whence)
-
-
-@jaseci_action(act_group=["fh"])
-def open(id: str, mode: str = "r", encoding: str = None, meta: dict = {}, **kwargs):
-    """temp"""
-    meta["h"].get_file_handler(id).open(mode, encoding, False, **kwargs)
-
-
-@jaseci_action(act_group=["fh"])
-def is_open(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).is_open()
-
-
-@jaseci_action(act_group=["fh"])
-def exists(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).exists()
-
-
-@jaseci_action(act_group=["fh"])
-def write(id: str, content: str, meta: dict = {}):
-    """temp"""
-    meta["h"].get_file_handler(id).write(content)
-
-
-@jaseci_action(act_group=["fh"])
-def flush(id: str, meta: dict = {}):
-    """temp"""
-    meta["h"].get_file_handler(id).flush()
-
-
-@jaseci_action(act_group=["fh"])
-def close(id: str, meta: dict = {}):
-    """temp"""
-    meta["h"].get_file_handler(id).close()
-
-
-@jaseci_action(act_group=["fh"])
-def detach(id: str, persist: bool = None, meta: dict = {}):
-    """temp"""
-    from jaseci.utils.file_handler import FileHandler
-
-    file_handler: FileHandler = meta["h"].pop_file_handler(id)
-    file_info = file_handler.attr()
-
-    if (persist is None and not file_handler.persist) or persist is False:
-        file_handler.delete()
-    else:
-        file_handler.close()
-
-    return file_info
-
-
-@jaseci_action(act_group=["fh"])
-def delete(id: str, meta: dict = {}):
-    """temp"""
-    meta["h"].pop_file_handler(id).delete()
-
-
-@jaseci_action(act_group=["fh"])
-def attr(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).attr()
-
-
-@jaseci_action(act_group=["fh"])
-def to_bytes(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).to_bytes()
-
-
-@jaseci_action(act_group=["fh"])
-def to_base64(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).to_base64()
-
-
-@jaseci_action(act_group=["fh"])
-def to_json(id: str, meta: dict = {}):
-    """temp"""
-    return meta["h"].get_file_handler(id).to_json()
-
-
-@jaseci_action(act_group=["fh"])
-def dump_json(id: str, json, indent: int = None, meta: dict = {}):
-    """temp"""
-    meta["h"].get_file_handler(id).dump_json(json, indent)
-
-
-@jaseci_action(act_group=["fh"])
-def download(url: str, header: dict = {}, meta: dict = {}):
-    """Standard built in for download file from url"""
-    from jaseci.utils.file_handler import FileHandler
-
-    tmp = FileHandler(path.basename(urlparse(url).path) or "file")
-    meta["h"].add_file_handler(tmp)
-
-    with get(url, stream=True, headers=header) as res:
-        res.raise_for_status()
-        tmp.open("wb+")
-        for chunk in res.iter_content(chunk_size=8192):
-            tmp.buffer.write(chunk)
-
-        tmp.content_type = magic.from_buffer(tmp.read(0), mime=True)
-        tmp.close()
-
-    return tmp.id

jaseci/extens/act_lib/internal.py

@@ -1,19 +0,0 @@
-"""Built in actions for Jaseci"""
-
-from jaseci.jsorc.live_actions import jaseci_action
-from jaseci.utils.utils import perf_test_start, perf_test_stop
-
-perf_tests = {}
-
-
-@jaseci_action()
-def start_perf_test(name: str = "default"):
-    perf_tests[name] = perf_test_start()
-
-
-@jaseci_action()
-def stop_perf_test(name: str = "default"):
-    if name not in perf_tests.keys():
-        return
-    calls, graph = perf_test_stop(perf_tests[name])
-    return {"calls": calls, "graph": graph}

jaseci/extens/act_lib/jaseci.py

@@ -1,62 +0,0 @@
-"""Built in actions for Jaseci"""
-
-from jaseci.jsorc.live_actions import jaseci_action
-from jaseci.utils.utils import master_from_meta, copy_func
-from jaseci.prim.super_master import SuperMaster
-import functools
-
-
-def interface_api(api_name, is_public, p_spec, *args, meta):
-    """
-    Interfaces Master apis after processing arguments/parameters
-    from cli
-    """
-    mast = master_from_meta(meta)
-    params = construct_params(p_spec, args)
-    if is_public:
-        return mast.public_interface_to_api(params, api_name)
-    else:
-        return mast.general_interface_to_api(params, api_name)
-
-
-def construct_params(p_spec, args):
-    arg_count = 0
-    params = {}
-    for i in p_spec.keys():
-        if i == "self":
-            continue
-        p_default = (
-            p_spec[i].default if p_spec[i].default is not p_spec[i].empty else None
-        )
-        if arg_count < len(args):
-            params[i] = args[arg_count]
-        else:
-            params[i] = p_default
-        arg_count += 1
-    return params
-
-
-def build_cmds():
-    """
-    Generates Click function with options for each command
-    group and leaf signatures
-    leaf is format: [api_name, func_sig, is_public, func_doc]
-    """
-
-    for i in SuperMaster.all_apis(None):
-        func_name = "_".join(i["groups"])
-        f = functools.partial(
-            copy_func(interface_api, func_name),
-            func_name,
-            i in SuperMaster._public_api,
-            i["sig"].parameters,
-        )
-        f.__name__ = func_name
-        f.__doc__ = i["doc"]
-        f.__module__ = __name__
-
-        # original_args = inspect.getargspec(func).args
-        globals()[func_name] = jaseci_action()(f)
-
-
-build_cmds()

jaseci/extens/act_lib/mail.py

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

jaseci/extens/act_lib/maths.py

@@ -1,168 +0,0 @@
-import math
-
-from jaseci.jsorc.live_actions import jaseci_action
-
-
-@jaseci_action()
-def ceil(x):
-    # return int
-    return math.ceil(x)
-
-
-@jaseci_action()
-def comb(n, k):
-    # return int
-    return math.comb(n, k)
-
-
-@jaseci_action()
-def copysign(x, y):
-    # return float
-    return math.copysign(x, y)
-
-
-@jaseci_action()
-def fabs(x):
-    # return float
-    return math.fabs(x)
-
-
-@jaseci_action()
-def factorial(n):
-    # return int
-    return math.factorial(n)
-
-
-@jaseci_action()
-def floor(x):
-    # return int
-    return math.floor(x)
-
-
-@jaseci_action()
-def fmod(x, y):
-    # return float
-    return math.fmod(x, y)
-
-
-@jaseci_action()
-def frexp(x):
-    # return tuple
-    _tuple = math.frexp(x)
-    return list(_tuple)
-
-
-@jaseci_action()
-def fsum(iterable: list):
-    # return float
-    return math.fsum(iterable)
-
-
-@jaseci_action()
-def gcd(args: list):
-    args = tuple(args)
-    # return int
-    return math.gcd(*args)
-
-
-@jaseci_action()
-def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
-    # return boolean
-    return math.isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)
-
-
-@jaseci_action()
-def isfinite(x):
-    # return boolean
-    return math.isfinite(x)
-
-
-@jaseci_action()
-def isinf(x):
-    # return boolean
-    return math.isinf(x)
-
-
-@jaseci_action()
-def isnan(x):
-    # return boolean
-    return math.isnan(x)
-
-
-@jaseci_action()
-def isqrt(n):
-    # return int
-    return math.isqrt(n)
-
-
-@jaseci_action()
-def lcm(args: list):
-    args = tuple(args)
-    # return int
-    return math.lcm(*args)
-
-
-@jaseci_action()
-def ldexp(x, i):
-    # return float
-    return math.ldexp(x, i)
-
-
-@jaseci_action()
-def modf(x):
-    _tupple = math.modf(x)
-    # return list
-    return list(_tupple)
-
-
-@jaseci_action()
-def nextafter(x, y):
-    # return float
-    return math.nextafter(x, y)
-
-
-@jaseci_action()
-def perm(n, k=None):
-    # return int
-    return math.perm(n, k)
-
-
-@jaseci_action()
-def prod(iterable, start=1):
-    return math.prod(iterable, start=start)
-
-
-@jaseci_action()
-def remainder(x, y):
-    # return float
-    return math.remainder(x, y)
-
-
-@jaseci_action()
-def trunc(x):
-    # return int
-    return math.trunc(x)
-
-
-@jaseci_action()
-def ulp(x):
-    # return float
-    return math.ulp(x)
-
-
-@jaseci_action()
-def cubert(x):
-    # return float
-    return x ** (1 / 3)
-
-
-@jaseci_action()
-def exp(x):
-    # return float
-    return math.exp(x)
-
-
-@jaseci_action()
-def log(x, base):
-    # return float
-    return math.log(x, base)