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

jaseci/extens/act_lib/tests/test_std_lib.py

@@ -1,36 +0,0 @@
-from jaseci.utils.test_core import CoreTest
-
-
-class StdLibTest(CoreTest):
-    fixture_src = __file__
-
-    def test_clear_report(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("general.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "report_clearing"}])
-        self.assertEqual(len(ret["report"]), 1)
-        self.assertEqual(ret["report"][0], 7)
-
-    def test_internal_lib(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("general.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "internal_lib"}])
-        self.assertEqual(len(ret["report"]), 1)
-        self.assertTrue(
-            ret["report"][0]["calls"].startswith(
-                "ncalls,tottime,percall,cumtime,percall,"
-            )
-        )
-
-    def test_rand_float_round(self):
-        ret = self.call(
-            self.mast,
-            ["sentinel_register", {"code": self.load_jac("general.jac")}],
-        )
-        ret = self.call(self.mast, ["walker_run", {"name": "rand_float_round"}])
-        self.assertEqual(ret["report"][0], 2.313)
-        self.assertEqual(ret["report"][1], 2.847)

jaseci/extens/act_lib/tests/test_url.py

@@ -1,32 +0,0 @@
-from jaseci.utils.test_core import CoreTest, jac_testcase
-
-
-class UrlTest(CoreTest):
-    fixture_src = __file__
-
-    @jac_testcase("url.jac", "is_valid_test")
-    def test_is_valid(self, ret):
-        self.assertEqual(
-            ret["report"],
-            [True, False, False],
-        )
-
-    @jac_testcase("url.jac", "ping_test")
-    def test_ping(self, ret):
-        self.assertEqual(
-            ret["report"],
-            [True, False, False, False],
-        )
-
-    @jac_testcase("url.jac", "download_text_test")
-    def test_download_text(self, ret):
-        # Download the jaseci homepage as a test
-        self.assertGreater(abs(len(ret["report"][0])), 0)
-
-    @jac_testcase("url.jac", "download_b64_test")
-    def test_download_b64(self, ret):
-        # Jaseci white paper is 2,034,680 bytes in base64
-        self.assertEqual(
-            len(ret["report"][0]),
-            2034680,
-        )

jaseci/extens/act_lib/tests/test_vector.py

@@ -1,36 +0,0 @@
-from jaseci.utils.test_core import CoreTest, jac_testcase
-
-
-class VectorTest(CoreTest):
-    """UnitTest for Vector Module"""
-
-    fixture_src = __file__
-
-    @jac_testcase("vector.jac", "get_centroid_test")
-    def test_get_centroid(self, ret):
-        ret = [ret["report"][0][0], round(ret["report"][0][1], 3)]
-        self.assertEqual(ret, [[1.0, 2.0, 3.5], 0.998])
-
-    @jac_testcase("vector.jac", "softmax_test")
-    def test_softmax(self, ret):
-        ret = [round(num, 2) for num in ret["report"][0]]
-        self.assertEqual(ret, [0.09, 0.24, 0.67])
-
-    @jac_testcase("vector.jac", "dot_product_test")
-    def test_dot_product(self, ret):
-        self.assertEqual(ret["report"][0], 17)
-
-    @jac_testcase("vector.jac", "cosine_similarity_test")
-    def test_cosine_similarity_single(self, ret):
-        ret = round(ret["report"][0], 3)
-        self.assertEqual(ret, 0.991)
-
-    @jac_testcase("vector.jac", "cosine_similarity_batch_test")
-    def test_cosine_similarity_batch(self, ret):
-        ret = [round(num, 2) for num in ret["report"][0]]
-        self.assertEqual(ret, [0.99, 1.0])
-
-    @jac_testcase("vector.jac", "dimensionality_reduction_test")
-    def test_dimensionality_reduction(self, ret):
-        ret = len(ret["report"][0][0])
-        self.assertEqual(ret, 2)

jaseci/extens/act_lib/tests/test_webtool.py

@@ -1,44 +0,0 @@
-from jaseci.utils.test_core import CoreTest, jac_testcase
-
-
-class WebtoolTest(CoreTest):
-    """UnitTest for Webtool"""
-
-    fixture_src = __file__
-
-    @jac_testcase("webtool.jac", "get_meta_valid")
-    def test_get_meta_valid(self, ret):
-        self.assertTrue(ret["success"])
-        expected_tags = set(["og:image", "og:type", "og:title"])
-        tags = set(
-            [
-                meta["property"] if "property" in meta else ""
-                for meta in ret["report"][0]
-            ]
-        )
-        self.assertTrue(tags.issuperset(expected_tags))
-
-    @jac_testcase("webtool.jac", "get_meta_need_auth")
-    def test_get_meta_need_auth(self, ret):
-        self.assertTrue(ret["success"])
-        self.assertTrue(len(ret["report"][0]) > 0)
-
-    @jac_testcase("webtool.jac", "get_meta_invalid")
-    def test_get_meta_invalid(self, ret):
-        self.assertTrue("Failed at getting metadata" in ret["report"][0])
-
-    @jac_testcase("webtool.jac", "get_meta_timeout")
-    def test_get_meta_timeout(self, ret):
-        self.assertTrue("Failed at getting metadata" in ret["report"][0])
-
-    @jac_testcase("webtool.jac", "get_meta_need_header")
-    def test_get_meta_need_header(self, ret):
-        self.assertTrue(ret["success"])
-        expected_tags = set(["og:image", "og:type", "og:title"])
-        tags = set(
-            [
-                meta["property"] if "property" in meta else ""
-                for meta in ret["report"][0]
-            ]
-        )
-        self.assertTrue(tags.issuperset(expected_tags))

jaseci/extens/act_lib/tests/test_zlib.py

@@ -1,24 +0,0 @@
-from jaseci.utils.test_core import CoreTest, jac_testcase
-
-
-class ZlibTest(CoreTest):
-    fixture_src = __file__
-
-    data_uncompressed = "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII="
-    data_compressed = "eJzrDPBz5+WS4mJgYOD19HAJAtIcIMzIDCT/HdQ5AaTYAnxCXP///79///7FzmWWQBE+TxfHEI7ryT8YWv8IcDDoMTD/XZyZdxEow+Dp6ueyzimhCQDLCRkd"
-
-    @jac_testcase("zlib.jac", "compress_test", True)
-    def test_compress(self, ret):
-        print(ret["report"])
-        self.assertEqual(
-            ret["report"][0],
-            self.data_compressed,
-        )
-
-    @jac_testcase("zlib.jac", "decompress_test")
-    def test_decompress(self, ret):
-        print(ret["report"])
-        self.assertEqual(
-            ret["report"][0],
-            self.data_uncompressed,
-        )

jaseci/extens/act_lib/url.py

@@ -1,79 +0,0 @@
-"""Built in actions for Jaseci"""
-from jaseci.jsorc.live_actions import jaseci_action
-from fastapi import HTTPException
-import base64
-import requests
-import urllib
-import validators
-
-
-@jaseci_action()
-def is_valid(url: str = ""):
-    """
-    Checks that a string is a valid url in its format
-    Param 1 - url string
-
-    Return - True if valid, False if not
-    """
-    try:
-        url_response = validators.url(url)
-        if isinstance(url_response, validators.ValidationError):
-            return False
-    except:
-        return False
-
-    return True
-
-
-@jaseci_action()
-def ping(url: str = ""):
-    """
-    Make sure that a url returns an error code in the 200s when pinged upon success
-    Param 1 - url string
-
-    Return - True if error code is in 200s, False if not
-    """
-    try:
-        response = requests.get(url)
-    except:
-        return False
-
-    return response.status_code in range(200, 299)
-
-
-@jaseci_action()
-def download_text(url: str = ""):
-    """
-    Downloaded html from a url
-    Param 1 - url string
-
-    Return - string containing html
-    """
-    try:
-        response = urllib.request.urlopen(url)
-    except:
-        raise HTTPException(status_code=404, detail="Invalid URL")
-
-    html_bytes = response.read()
-    html_str = html_bytes.decode("UTF-8")
-    print(len(html_str))
-    return html_str
-
-
-@jaseci_action()
-def download_b64(url: str = ""):
-    """
-    Downlaod the get response from a url and return it in base64
-    Param 1 - url string
-
-    Return - base64 string representing the get response
-    """
-    try:
-        response = requests.get(url)
-    except:
-        raise HTTPException(status_code=404, detail="Invalid URL")
-
-    response_bytes = response.content
-    response_b64_bytes = base64.b64encode(response_bytes)
-    response_b64 = response_b64_bytes.decode("ascii")
-    return response_b64

jaseci/extens/act_lib/vector.py

@@ -1,157 +0,0 @@
-"""Built in actions for Jaseci"""
-import numpy as np
-from operator import itemgetter
-import pickle, base64
-
-from jaseci.jsorc.live_actions import jaseci_action
-
-
-def check_nested_list(lst):
-    return all(isinstance(el, list) for el in lst)
-
-
-@jaseci_action(aliases=["cos_sim"])
-def cosine_sim(vec_a: list, vec_b: list):
-    """
-    Caculate the cosine similarity score of two given vectors
-    Param 1 - First vector
-    Param 2 - Second vector
-
-    Return - float between 0 and 1
-    """
-    vec_a_nested = check_nested_list(vec_a)
-    vec_b_nested = check_nested_list(vec_b)
-    if vec_a_nested or vec_b_nested:
-        vec_a_np = np.array(vec_a) if vec_a_nested else np.array([vec_a] * len(vec_b))
-        vec_b_np = np.array(vec_b) if vec_b_nested else np.array([vec_b] * len(vec_a))
-        sim = np.dot(vec_a_np, vec_b_np.T) / (
-            np.linalg.norm(vec_a_np, axis=1)[:, None] * np.linalg.norm(vec_b_np, axis=1)
-        )
-        return sim.diagonal().tolist()
-
-    result = np.dot(vec_a, vec_b) / (np.linalg.norm(vec_a) * np.linalg.norm(vec_b))
-    return float(result.astype(float))
-
-
-@jaseci_action()
-def dot_product(vec_a: list, vec_b: list):
-    """
-    Caculate the dot product of two given vectors
-    Param 1 - First vector
-    Param 2 - Second vector
-
-    Return - float between 0 and 1
-    """
-
-    return np.inner(vec_a, vec_b).tolist()
-
-
-@jaseci_action()
-def get_centroid(vec_list: list):
-    """
-    Calculate the centroid of the given list of vectors
-    Param 1 - List of vectors
-
-    Return - (centroid vector, cluster tightness)
-    """
-    centroid = np.mean(vec_list, axis=0)
-    tightness = np.mean([cosine_sim(vec, centroid) for vec in vec_list]).astype(float)
-    return [centroid.tolist(), tightness]
-
-
-@jaseci_action()
-def softmax(vec_list: list):
-    """
-    Calculate the centroid of the given list of vectors
-    Param 1 - List of vectors
-
-    Return - (centroid vector, cluster tightness)
-    """
-    e_x = np.exp(vec_list - np.max(vec_list))
-    return list(e_x / e_x.sum())
-
-
-@jaseci_action()
-def sort_by_key(data: dict, reverse=False, key_pos=None):
-    """
-    Sort the given list. Optionally by specific key
-    Param 1 - List of items
-    Param 2 - if Reverse
-    Param 3 (Optional) - Index of the key to be used for sorting
-    if param 1 is a list of tuples.
-
-    Deprecated
-    """
-    if key_pos is not None:
-        return sorted(data, key=itemgetter(key_pos), reverse=reverse)
-    else:
-        return sorted(data, reverse=reverse)
-
-
-@jaseci_action()
-def dim_reduce_fit(data: list, dim=2):
-    """
-    Dimensionally reduce a list of vectors using incremental PCA
-    Param 1 - List of vectors
-    Param 2 - Dimension to reduce to
-
-    Return - base64 encoded string of the model
-    """
-    data_arr = np.array(data)
-    ipca = IncrementalPCA(n_components=dim)
-    ipca = ipca.fit(data_arr)
-    return base64.b64encode(pickle.dumps(ipca)).decode("utf-8")
-
-
-@jaseci_action()
-def dim_reduce_apply(data: list, model: str):
-    """
-    Dimensionally reduce a list of vectors using incremental PCA
-    Param 1 - List of vectors
-    Param 2 - base64 encoded string of the model
-
-    Return - List of reduced vectors
-    """
-    data_arr = np.array(data)
-    # reshaping the data if it is a single vector
-    if len(data_arr.shape) == 1:
-        data_arr = data_arr.reshape(1, -1)
-    ipca = pickle.loads(base64.b64decode(model))
-    return ipca.transform(data_arr).tolist()
-
-
-class IncrementalPCA:
-    def __init__(self, n_components):
-        self.n_components = n_components
-        self.mean_ = None
-        self.components_ = None
-        self.n_samples_seen_ = 0
-
-    def fit(self, X):
-        if self.mean_ is None:
-            self.mean_ = np.zeros(X.shape[1], dtype=np.float64)
-        if self.components_ is None:
-            self.components_ = np.zeros(
-                (self.n_components, X.shape[1]), dtype=np.float64
-            )
-
-        # update mean
-        col_mean = np.mean(X, axis=0)
-        total_n_samples = self.n_samples_seen_ + X.shape[0]
-        self.mean_ = (
-            self.n_samples_seen_ * self.mean_ + X.shape[0] * col_mean
-        ) / total_n_samples
-
-        # update components
-        X_centered = X - self.mean_
-        U, S, V = np.linalg.svd(X_centered, full_matrices=False)
-        explained_variance = S**2 / (X.shape[0] - 1)
-        explained_variance_ratio = explained_variance / np.sum(explained_variance)
-        self.components_ = V[: self.n_components]
-        self.n_samples_seen_ = total_n_samples
-
-        return self
-
-    def transform(self, X):
-        X_centered = X - self.mean_
-        return np.dot(X_centered, self.components_.T)

jaseci/extens/act_lib/webtool.py

@@ -1,28 +0,0 @@
-"""Built in actions for Jaseci"""
-import requests
-from jaseci.jsorc.live_actions import jaseci_action
-from bs4 import BeautifulSoup
-
-
-@jaseci_action()
-def get_page_meta(url: str, timeout: int = 3, parser: str = "lxml", headers: dict = {}):
-    """
-    Util to parse metadata out of urls and html documents
-    Parser option: lxml (default), html5lib, html.parser
-    Comparison between parsers: https://www.crummy.com/software/BeautifulSoup/bs4/doc/#installing-a-parser
-    """
-    try:
-        webpage = requests.get(
-            url,
-            timeout=timeout,
-            headers=headers,
-        )
-        soup = BeautifulSoup(webpage.content, features=parser)
-        meta = soup.find_all("meta")
-        meta_list = []
-        for tag in meta:
-            meta_list.append(dict(tag.attrs))
-        return meta_list
-    except Exception as e:
-        print("Failed")
-        return f"Failed at getting metadata for {url}: {str(e)}"

jaseci/extens/act_lib/zip.py

@@ -1,33 +0,0 @@
-"""Built in actions for Jaseci"""
-from jaseci.jsorc.live_actions import jaseci_action
-from jaseci.utils.utils import print_stack_to_log
-from base64 import b64decode, b64encode
-import zlib
-
-
-@jaseci_action()
-def compress(data_b64: str = ""):
-    """
-    Compress data
-    Param 1 - data in base64
-
-    Return - compressed data in base64
-    """
-    data_bytes = b64decode(data_b64.encode("ascii"))
-    data_compressed_bytes = zlib.compress(data_bytes)
-    data_compressed_b64 = b64encode(data_compressed_bytes).decode("ascii")
-    return data_compressed_b64
-
-
-@jaseci_action()
-def decompress(data_b64: str = ""):
-    """
-    Decompress data
-    Param 1 - data in base64
-
-    Return - decompressed data in base64
-    """
-    data_bytes = b64decode(data_b64.encode("ascii"))
-    data_decompressed_bytes = zlib.decompress(data_bytes)
-    data_decompressed_b64 = b64encode(data_decompressed_bytes).decode("ascii")
-    return data_decompressed_b64

jaseci/extens/api/actions_api.py

@@ -1,170 +0,0 @@
-"""
-Admin Global api functions as a mixin
-"""
-from jaseci.extens.api.interface import Interface
-import jaseci.jsorc.live_actions as lact
-import json
-
-
-class ActionsApi:
-    """
-    APIs to manage actions
-
-    This set action APIs enable the manual management of Jaseci actions and action
-    libraries/sets. Action libraries can be loaded locally into the running instance of
-    the python program, or as a remote container linked action library. In this mode,
-    action libraries operate as micro-services. Jaseci will be able to dynamically
-    and automatically make this decision for the user based on online monitoring and
-    performance profiling.
-    """
-
-    @Interface.admin_api(cli_args=["file"])
-    def actions_load_local(self, file: str, ctx: dict = {}):
-        """
-        Hot load a python module and assimilate any Jaseci Actions
-
-        This API will dynamically load a module based on a python file. The module
-        is loaded directly into the running Jaseci python instance. This API also
-        makes an attempt to auto detect and hot load any python package dependencies
-        the file may reference via python's relative imports. This file is assumed to
-        have the necessary annotations and decorations required by Jaseci to recognize
-        its actions.
-
-        :param file: The python file with full to load actions from.
-            (i.e., ~/local/myact.py)
-        """
-        success = lact.load_local_actions(file, ctx=ctx)
-        if success:
-            cur_config = self.config_get("ACTION_SETS")
-            if cur_config and (not isinstance(cur_config, list)):
-                config = json.loads(cur_config)
-                if file not in config["local"]:
-                    config["local"].append(file)
-                    self.config_set("ACTION_SETS", json.dumps(config))
-            else:
-                self.config_set(
-                    "ACTION_SETS",
-                    json.dumps({"local": [file], "remote": [], "module": []}),
-                )
-        return {"success": success}
-
-    @Interface.admin_api(cli_args=["url"])
-    def actions_load_remote(self, url: str, ctx: dict = {}):
-        """
-        Hot link to a container linked action library
-
-        This API will dynamically load a set of actions that are present on a remote
-        server/micro-service. This server must be configured to interact with Jaseci
-        properly. This is easily achieved using the same decorators used for local
-        action libraries. Remote actions allow for higher flexibility in the languages
-        supported for action libraries. If an  library writer would like to use another
-        language, the main hook REST api simply needs to be implemented. Please
-        refer to documentation on creating action libraries for more details.
-
-        :param url: The url of the API server supporting Jaseci actions.
-        """
-        success = lact.load_remote_actions(url, ctx=ctx)
-        if success:
-            cur_config = self.config_get("ACTION_SETS")
-            if cur_config and (not isinstance(cur_config, list)):
-                config = json.loads(cur_config)
-                if url not in config["remote"]:
-                    config["remote"].append(url)
-                    self.config_set("ACTION_SETS", json.dumps(config))
-            else:
-                self.config_set(
-                    "ACTION_SETS",
-                    json.dumps({"local": [], "remote": [url], "module": []}),
-                )
-        return {"success": success}
-
-    @Interface.admin_api(cli_args=["mod"])
-    def actions_load_module(self, mod: str, ctx: dict = {}):
-        """
-        Hot load a python module and assimilate any Jaseci Actions
-
-        This API will dynamically load a module using python's module import format.
-        This is particularly useful for pip installed action libraries as the developer
-        can directly reference the module using the same format as a regular python
-        import. As with load local, the module will be loaded directly into the running
-        Jaseci python instance.
-
-        :param mod: The import style module to load actions from.
-            (i.e., jaseci_ai_kit.bi_enc)
-        """
-        success = lact.load_module_actions(mod, ctx=ctx)
-        if success:
-            cur_config = self.config_get("ACTION_SETS")
-            if cur_config and (not isinstance(cur_config, list)):
-                config = json.loads(cur_config)
-                if mod not in config["module"]:
-                    config["module"].append(mod)
-                    self.config_set("ACTION_SETS", json.dumps(config))
-            else:
-                self.config_set(
-                    "ACTION_SETS",
-                    json.dumps({"local": [], "remote": [], "module": [mod]}),
-                )
-        return {"success": success}
-
-    # @interface.admin_api()
-    # def actions_get(self, name: str, value: str):
-    #     """
-    #     """
-
-    @Interface.admin_api()
-    def actions_list(self, name: str = ""):
-        """
-        List a set of or all loaded jaseci actions
-
-        This API is used to list the loaded actions active in Jaseci. These actions
-        include all types of loaded actions whether it be local modules or remote
-        containers. A particular set of actions can be viewed using the name parameter.
-
-        :param name: The name for a library for which to filter the view of shown
-            actions. If left blank all actions from all loaded sets will be shown.
-        """
-        actions = list(lact.live_actions.keys())
-        if len(name):
-            actions = list(filter(lambda a: a.startswith(name), actions))
-        return actions
-
-    @Interface.admin_api()
-    def actions_module_list(self, detailed: bool = False):
-        """
-        List all modules loaded for actions
-        """
-        if not detailed:
-            action_mods = list(lact.live_action_modules.keys())
-        else:
-            action_mods = lact.live_action_modules
-        return action_mods
-
-    @Interface.admin_api(cli_args=["name"])
-    def actions_unload_module(self, name: str):
-        """
-        Unload modules loaded for actions
-        """
-        return {"success": lact.unload_module(name)}
-
-    @Interface.admin_api(cli_args=["name"])
-    def actions_unload_action(self, name: str):
-        """
-        Unload modules loaded for actions
-        """
-        return {"success": lact.unload_action(name)}
-
-    @Interface.admin_api(cli_args=["name"])
-    def actions_unload_actionset(self, name: str):
-        """
-        Unload modules loaded for actions
-        """
-        return {"success": lact.unload_actionset(name)}
-
-    @Interface.admin_api(cli_args=["name"])
-    def actions_call(self, name: str, ctx: dict = {}):
-        """
-        Call an action by name
-        """
-        ret, sucess = lact.call_action(name, ctx=ctx)
-        return {"success": sucess, "result": ret}