jaseci 1.4.1.8__tar.gz → 1.4.2__tar.gz

jaseci-1.4.2/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: jaseci
+Version: 1.4.2
+Home-page: https://github.com/Jaseci-Labs/jaseci
+Author: Jason Mars
+Author-email: jason@jaseci.org
+License-File: LICENSE
+Requires-Dist: click<8.2.0,>=8.1.0
+Requires-Dist: click-shell<2.2,>=2.1
+Requires-Dist: numpy<1.24.0,>=1.23.0
+Requires-Dist: antlr4-python3-runtime<4.10.0,>=4.9.3
+Requires-Dist: fastapi[all]<1.0.0,>=0.75.0
+Requires-Dist: requests
+Requires-Dist: redis
+Requires-Dist: celery<6,>=5
+Requires-Dist: flake8
+Requires-Dist: pep8-naming
+Requires-Dist: stripe
+Requires-Dist: pydantic<2.0.0
+Requires-Dist: docstring-parser
+Requires-Dist: prometheus_api_client==0.5.1
+Requires-Dist: prometheus-client==0.14.1
+Requires-Dist: kubernetes==23.6.0
+Requires-Dist: pytest
+Requires-Dist: pytest-xdist
+Requires-Dist: pytest-cov
+Requires-Dist: validators==0.21.2
+Requires-Dist: psycopg2-binary==2.9.5
+Requires-Dist: pygls
+Requires-Dist: mock
+Requires-Dist: beautifulsoup4<4.13.0,>=4.12.2
+Requires-Dist: lxml<4.10.0,>=4.9.2
+Requires-Dist: html5lib<1.2,>=1.1
+Requires-Dist: prettytable<3.8.0,>=3.7.0
+Requires-Dist: apache-libcloud==3.7.0

jaseci-1.4.2/jaseci/VERSION

@@ -0,0 +1 @@
+1.4.2

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/act_lib/request.py

@@ -4,7 +4,7 @@ from jaseci.jsorc.live_actions import jaseci_action
 
 
 @jaseci_action()
-def get(url: str, data: dict, header: dict):
+def get(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url
@@ -23,7 +23,7 @@ def get(url: str, data: dict, header: dict):
 
 
 @jaseci_action()
-def post(url: str, data: dict, header: dict):
+def post(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url
@@ -42,7 +42,7 @@ def post(url: str, data: dict, header: dict):
 
 
 @jaseci_action()
-def put(url: str, data: dict, header: dict):
+def put(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url
@@ -61,7 +61,7 @@ def put(url: str, data: dict, header: dict):
 
 
 @jaseci_action()
-def delete(url: str, data: dict, header: dict):
+def delete(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url
@@ -80,7 +80,7 @@ def delete(url: str, data: dict, header: dict):
 
 
 @jaseci_action()
-def head(url: str, data: dict, header: dict):
+def head(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url
@@ -99,7 +99,7 @@ def head(url: str, data: dict, header: dict):
 
 
 @jaseci_action()
-def options(url: str, data: dict, header: dict):
+def options(url: str, data: dict = {}, header: dict = {}):
     """
     Issue request
     Param 1 - url

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/act_lib/stripe.py

@@ -4,7 +4,6 @@ import stripe as s
 from jaseci.jsorc.jsorc import JsOrc
 from jaseci.utils.utils import logger
 from jaseci.extens.svc.stripe_svc import StripeService
-from datetime import datetime
 from jaseci.jsorc.live_actions import jaseci_action
 
 
@@ -168,6 +167,15 @@ def invoice_retrieve(invoice_id: str, **kwargs):
     return stripe().Invoice.retrieve(invoice_id, **kwargs)
 
 
+@jaseci_action()
+def subscription_item_list_usage_record_summaries(subscription_item_id: str, **kwargs):
+    """Create usage record"""
+
+    return stripe().SubscriptionItem.list_usage_record_summaries(
+        subscription_item_id, **kwargs
+    )
+
+
 @jaseci_action()
 def subscription_item_create_usage_record(
     subscription_item_id: str, quantity: int, **kwargs
@@ -175,7 +183,7 @@ def subscription_item_create_usage_record(
     """Create usage record"""
 
     return stripe().SubscriptionItem.create_usage_record(
-        subscription_item_id, quantity=quantity, timestamp=datetime.now(), **kwargs
+        subscription_item_id, quantity=quantity, timestamp="now", **kwargs
     )
 
 

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/act_lib/task.py

@@ -5,9 +5,9 @@ from jaseci.extens.svc.task_svc import TaskService
 
 
 @jaseci_action()
-def get_result(task_id, wait, meta):
+def get_result(task_id, wait=False, timeout=30):
     """
     Get task result by task_id
     """
 
-    return JsOrc.svc("task").poke(TaskService).get_by_task_id(task_id, wait)
+    return JsOrc.svc("task").poke(TaskService).get_by_task_id(task_id, wait, timeout)

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/act_lib/url.py

@@ -17,7 +17,7 @@ def is_valid(url: str = ""):
     """
     try:
         url_response = validators.url(url)
-        if isinstance(url_response, validators.ValidationFailure):
+        if isinstance(url_response, validators.ValidationError):
             return False
     except:
         return False

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/api/global_api.py

@@ -42,17 +42,26 @@ class GlobalApi:
     @Interface.admin_api()
     def global_sentinel_set(self, snt: Sentinel = None):
         """
-        Set sentinel as globally accessible
+        Make a sentinel globally accessible and set it as the global sentinel
         """
         snt.make_read_only()
         snt.propagate_access()
         self._h.save_glob("GLOB_SENTINEL", snt.jid)
         return {"response": f"Global sentinel set to '{snt}'!"}
 
+    @Interface.admin_api()
+    def global_sentinel_set_access(self, snt: Sentinel = None):
+        """
+        Make a sentinel globally accessible
+        """
+        snt.make_read_only()
+        snt.propagate_access()
+        return {"response": f"Sentinel '{snt}' is now globally accessible."}
+
     @Interface.admin_api()
     def global_sentinel_unset(self):
         """
-        Set sentinel as globally accessible
+        Unset a global sentinel
         """
         current = self.global_get("GLOB_SENTINEL")["value"]
         if current:

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/api/user_api.py

@@ -26,7 +26,7 @@ class UserApi:
         global_init: str = "",
         global_init_ctx: dict = {},
         other_fields: dict = {},
-        send_email: bool = False,
+        send_email: bool = True,
     ):
         """
         Create a new user (master object)

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/api/webhook_api.py

@@ -25,7 +25,8 @@ class WebhookApi:
 
             # to be updated
             stripe_service.get_event(
-                self._h.get_file_handler(_req_ctx["raw"]), _req_ctx["headers"]
+                self._h.get_file_handler(_req_ctx["raw"]).to_bytes(),
+                _req_ctx["headers"],
             )
 
             payload_obj = req_body.get("data").get("object")
@@ -69,5 +70,5 @@ class WebhookApi:
             )
         else:
             raise HTTPException(
-                status_code=400, detail=str(type + " webhook is not yet supported")
+                status_code=400, detail=str(provider + " webhook is not yet supported")
             )

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/extens/svc/elastic_svc.py

@@ -62,6 +62,7 @@ class ElasticService(JsOrc.CommonService):
                 if cert:
                     with open("elastic-certificate.crt", "w") as cert_file:
                         cert_file.write(cert)
+                    self.config["verifier"] = "elastic-certificate.crt"
 
                 if not self.config.get("auth"):
                     auth = kube.get_secret(
@@ -80,8 +81,12 @@ class ElasticService(JsOrc.CommonService):
         under_test = self.config.get("under_test", False)
         if not under_test:
             self.configure_elastic()
-        LOG_QUEUES["core"] = self.add_elastic_log_handler(logger, "core", under_test)
-        LOG_QUEUES["app"] = self.add_elastic_log_handler(app_logger, "app", under_test)
+        LOG_QUEUES["core"] = self.add_elastic_log_handler(
+            logger, self.config.get("core_log_index") or "core", under_test
+        )
+        LOG_QUEUES["app"] = self.add_elastic_log_handler(
+            app_logger, self.config.get("app_log_index") or "app", under_test
+        )
 
     def configure_elastic(self):
         """
@@ -131,6 +136,21 @@ class ElasticService(JsOrc.CommonService):
                     try:
                         record = log_queue.get()
                         if record is None:
+                            # This is temporary
+                            # for debugging purposes
+                            from datetime import datetime
+
+                            self.app.doc(
+                                {
+                                    "@timestamp": datetime.now().strftime(
+                                        "%Y-%m-%dT%H:%M:%S"
+                                    ),
+                                    "message": f"Stopping process for {elastic_index}",
+                                    "level": "SYSTEM",
+                                },
+                                index=elastic_index,
+                            )
+                            # end of temporary code
                             break
                         elastic_record = format_elastic_record(record)
                         self.app.doc(log=elastic_record, index=elastic_index)
@@ -168,12 +188,14 @@ class Elastic:
         if config["auth"]:
             self.headers["Authorization"] = config["auth"]
 
+        self.verifier = config.get("verifier")
+
     def _get(self, url: str, json: dict = None):
         return get(
             f"{self.url}{url}",
             json=json,
             headers=self.headers,
-            verify="elastic-certificate.crt",
+            verify=self.verifier,
         ).json()
 
     def _post(self, url: str, json: dict = None):
@@ -181,7 +203,7 @@ class Elastic:
             f"{self.url}{url}",
             json=json,
             headers=self.headers,
-            verify="elastic-certificate.crt",
+            verify=self.verifier,
         ).json()
 
     def post(self, url: str, body: dict, index: str = "", suffix: str = ""):
@@ -233,7 +255,7 @@ class Elastic:
             res = get(
                 f"{self.url}/_ilm/policy/{policy_name}",
                 headers=self.headers,
-                verify="elastic-certificate.crt",
+                verify=self.verifier,
             )
             if res.status_code == 200 and policy_name in res.json():
                 # policy already exists
@@ -242,7 +264,7 @@ class Elastic:
             f"{self.url}/_ilm/policy/{policy_name}",
             headers=self.headers,
             json=policy_config,
-            verify="elastic-certificate.crt",
+            verify=self.verifier,
         )
         if res.status_code == 200:
             return res.json()
@@ -256,7 +278,7 @@ class Elastic:
             res = get(
                 f"{self.url}/_index_template/{template_name}",
                 headers=self.headers,
-                verify="elastic-certificate.crt",
+                verify=self.verifier,
             )
             if res.status_code == 200 and template_name in res.json():
                 # policy already exists
@@ -265,7 +287,7 @@ class Elastic:
             f"{self.url}/_index_template/{template_name}",
             headers=self.headers,
             json=template_config,
-            verify="elastic-certificate.crt",
+            verify=self.verifier,
         )
         if res.status_code == 200:
             return res.json()

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jac/interpreter/architype_interp.py

@@ -188,7 +188,6 @@ class ArchitypeInterp(Interp):
             return obj
         else:
             self.rt_error("Graph didn't produce root node!", kid[3])
-            return None
 
     def run_has_root(self, jac_ast):
         """

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jac/interpreter/interp.py

@@ -221,8 +221,7 @@ class Interp(VirtualMachine):
                     self._loop_ctrl = None
                     break
                 if loops > self._loop_limit:
-                    self.rt_error("Hit loop limit, breaking...", kid[0])
-                    self._loop_ctrl = "break"
+                    self.rt_error(f"Hit loop limit [{self._loop_limit}]!", kid[0])
                 self.run_expression(kid[3])
         elif kid[3].name == "expression":
             var = self._jac_scope.get_live_var(kid[1].token_text(), create_mode=True)
@@ -240,8 +239,7 @@ class Interp(VirtualMachine):
                         self._loop_ctrl = None
                         break
                     if loops > self._loop_limit:
-                        self.rt_error("Hit loop limit, breaking...", kid[0])
-                        self._loop_ctrl = "break"
+                        self.rt_error(f"Hit loop limit [{self._loop_limit}]!", kid[0])
             else:
                 self.rt_error("Not a list/dict for iteration!", kid[3])
         else:
@@ -269,8 +267,7 @@ class Interp(VirtualMachine):
                         self._loop_ctrl = None
                         break
                     if loops > self._loop_limit:
-                        self.rt_error("Hit loop limit, breaking...", kid[0])
-                        self._loop_ctrl = "break"
+                        self.rt_error(f"Hit loop limit [{self._loop_limit}]!", kid[0])
             else:
                 self.rt_error("Not a list/dict for iteration!", kid[5])
         if self._loop_ctrl and self._loop_ctrl == "continue":
@@ -291,8 +288,7 @@ class Interp(VirtualMachine):
                 self._loop_ctrl = None
                 break
             if loops > self._loop_limit:
-                self.rt_error("Hit loop limit, breaking...", kid[0])
-                self._loop_ctrl = "break"
+                self.rt_error(f"Hit loop limit [{self._loop_limit}]!", kid[0])
             self.run_expression(kid[1])
         if self._loop_ctrl and self._loop_ctrl == "continue":
             self._loop_ctrl = None
@@ -625,17 +621,11 @@ class Interp(VirtualMachine):
                     # Add additional accessible fields
                     return JacValue(self, value=self.get_info())
                 else:
-                    self.rt_error(f"Global {kid[0].name} not yet", jac_ast)
-                    return JacValue(
-                        self,
-                    )
+                    self.rt_error(f"Global {kid[0].name} is not supported!", jac_ast)
             else:
                 token = kid[2].token_text()
                 if token not in self.parent().global_vars:
                     self.rt_error(f"Global not defined - {token}", kid[2])
-                    return JacValue(
-                        self,
-                    )
 
                 return JacValue(self, ctx=self.parent().global_vars, name=token)
 
@@ -803,7 +793,6 @@ class Interp(VirtualMachine):
                 return self.parent().arch_ids.get_obj_by_name(name=name, kind=kind)
             else:
                 self.rt_error(f"{name} is not a super arch of {base_arch.name}", kid[1])
-                return None
         else:
             return base_arch
 
@@ -838,7 +827,6 @@ class Interp(VirtualMachine):
                     return JacValue(self, value=nd)
 
         self.rt_error(f"{result.value} not valid reference", kid[1])
-        return result
 
     def run_built_in(self, jac_ast, atom_res):
         """
@@ -960,7 +948,6 @@ class Interp(VirtualMachine):
                 self.rt_error(
                     f"Cannot get keys of {atom_res}. " f"Not Dictionary!", kid[0]
                 )
-                return JacValue(self, value=[])
         elif len(kid) > 1 and kid[1].name == "name_list":
             filter_on = self.run_name_list(kid[1])
             d = atom_res.value
@@ -1032,7 +1019,6 @@ class Interp(VirtualMachine):
                 self.rt_error(
                     f"Cannot get length of {atom_res.value}. Not List!", kid[0]
                 )
-                return JacValue(self, value=0)
         else:
             if not self.rt_check_type(atom_res.value, [list], kid[0]):
                 return atom_res
@@ -1408,7 +1394,6 @@ class Interp(VirtualMachine):
                     f"Indicies must be an integer or string!",
                     kid[1],
                 )
-                return atom_res
             try:
                 return JacValue(self, ctx=atom_res.value, name=idx)
             except Exception as e:
@@ -1423,7 +1408,6 @@ class Interp(VirtualMachine):
                     "List slice range not valid. Indicies must be an integers!",
                     kid[1],
                 )
-                return atom_res
             try:
                 return JacValue(self, ctx=atom_res.value, name=idx, end=end)
             except Exception as e:
@@ -1663,7 +1647,6 @@ class Interp(VirtualMachine):
             return self.pop().value
         else:
             self.rt_error(f"{name} not present in object", kid[0])
-            return False
 
     def run_any_type(self, jac_ast):
         """

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jac/interpreter/sentinel_interp.py

@@ -234,7 +234,6 @@ class SentinelInterp(Interp):
             graph_name = kid[0].kid[-1].token_text()
             if not self.arch_ids.has_obj_by_name(graph_name, kind="graph"):
                 self.rt_error(f"Graph {graph_name} not found!", kid[0])
-                return
             testcase["graph_ref"] = graph_name
         else:
             kid = kid[1:]
@@ -244,7 +243,6 @@ class SentinelInterp(Interp):
             walker_name = kid[0].kid[-1].token_text()
             if not self.arch_ids.has_obj_by_name(name=walker_name, kind="walker"):
                 self.rt_error(f"Walker {walker_name} not found!", kid[0])
-                return
             testcase["walker_ref"] = walker_name
             kid = kid[1:]
             if kid[0].name == "spawn_ctx":

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jac/interpreter/walker_interp.py

@@ -205,7 +205,6 @@ class WalkerInterp(Interp):
             result = act.run_action(param_list, self._jac_scope, self, jac_ast)
         except Exception as e:
             self.rt_error(e, jac_ast)
-            result = None
         if kid[-1].name == "expression":
             self.run_expression(kid[-1])
             dest = self.pop()

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jac/machine/machine_state.py

@@ -164,7 +164,6 @@ class MachineState:
             self.rt_error(
                 f"Variable not defined - {name}", jac_ast or self._cur_jac_ast
             )
-            self.push(JacValue(self))
         else:
             self.push(val)
 
@@ -183,12 +182,10 @@ class MachineState:
         if dest.check_assignable(jac_ast):
             if not self.rt_check_type(dest.value, [Node, Edge], jac_ast):
                 self.rt_error("Copy fields only applies to nodes and edges", jac_ast)
-                self.push(dest)
             if dest.value.name != src.value.name:
                 self.rt_error(
                     f"Node/edge arch {dest.value} don't match {src.value}!", jac_ast
                 )
-                self.push(dest)
             for i in src.value.context.keys():
                 if i in dest.value.context.keys():
                     JacValue(
@@ -304,6 +301,11 @@ class MachineState:
         error = self.rt_log_str(error, jac_ast)
         logger.warning(str(error))
 
+    def rt_subtle_error(self, error, jac_ast=None):
+        error = self.rt_log_str(error, jac_ast)
+        logger.error(str(error))
+        self.runtime_errors.append(error)
+
     def rt_error(self, error, jac_ast, append=False):
         """Prints runtime error to screen"""
 
@@ -355,7 +357,6 @@ class MachineState:
             f"expecting {typ}",
             jac_ast,
         )
-        return False
 
     def get_info(self):
         return {

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jsorc/jsorc_settings.py

@@ -172,6 +172,8 @@ class JsOrcSettings:
         "auth": os.getenv("ELASTIC_AUTH"),
         "common_index": f"{KUBE_NAMESPACE}-common",
         "activity_index": f"{KUBE_NAMESPACE}-activity",
+        "core_log_index": "core",
+        "app_log_index": "app",
         "ilm_policy_name": ELASTIC_ILM_POLICY_NAME,
         "ilm_policy": ELASTIC_ILM_POLICY,
         "index_template_name": ELASTIC_INDEX_TEMPLATE_NAME,

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jsorc/live_actions.py

@@ -11,6 +11,10 @@ import sys
 import inspect
 import importlib
 import gc
+import re
+
+var_args = re.compile(r"^\*[^\*]")
+var_kwargs = re.compile(r"^\*\*[^\*]")
 
 live_actions = {}  # {"act.func": func_obj, ...}
 live_action_modules = {}  # {__module__: ["act.func1", "act.func2", ...], ...}
@@ -305,14 +309,32 @@ def gen_remote_func_hook(url, act_name, param_names):
 
     def func(*args, **kwargs):
         params = {}
-        for i in range(len(param_names)):
-            if i < len(args):
-                params[param_names[i]] = args[i]
+        _args = list(args)
+        _param_names: list = param_names.copy()
+
+        args_len = len(args)
+        for idx, name in enumerate(param_names):
+            if idx >= args_len or not _args:
+                break
+            _param_names.remove(name)
+            if var_args.match(name):
+                if _args:
+                    params[name] = _args
+                break
             else:
-                params[param_names[i]] = None
-        for i in kwargs.keys():
-            if i in param_names:
-                params[i] = kwargs[i]
+                params[name] = _args.pop(0)
+
+        for name in _param_names:
+            if var_args.match(name):
+                if _args:
+                    params[name] = _args
+            elif var_kwargs.match(name):
+                if kwargs:
+                    params[name] = kwargs
+                break
+            elif name in kwargs:
+                params[name] = kwargs.pop(name)
+
         # Remove any None-valued parameters to use the default value of the action def
         params = dict([(k, v) for k, v in params.items() if v is not None])
         act_url = f"{url.rstrip('/')}/{act_name.split('.')[-1]}"

{jaseci-1.4.1.8 → jaseci-1.4.2}/jaseci/jsorc/remote_actions.py

@@ -9,7 +9,12 @@ 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 = []
@@ -51,12 +56,15 @@ def serv_actions():
 def gen_api_service(app, func, act_group, aliases, caller_globals):
     """Helper for jaseci_action decorator"""
     # Construct list of action apis available
-    varnames = list(inspect.signature(func).parameters.keys())
     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
@@ -64,19 +72,62 @@ def gen_api_service(app, func, act_group, aliases, caller_globals):
 
     # Keep only fields present in param list in base model
     keep_fields = {}
-    for i in model.__fields__.keys():
-        if i in varnames:
-            keep_fields[i] = model.__fields__[i]
+    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()):
-        pl_peek = str(dict(params.__dict__))[:128]
+        params: dict = params.__dict__
+        pl_peek = str(params)[:128]
         logger.info(str(f"Incoming call to {func.__name__} with {pl_peek}"))
         start_time = time()
 
-        ret = validate_arguments(func)(**(params.__dict__))
+        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(