@voxgig/sdkgen 0.35.2 → 0.36.0

package/project/.sdk/tm/py/utility/make_point.py

@@ -0,0 +1,74 @@
+# ProjectName SDK utility: make_point
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.helpers import to_map
+
+
+def make_point_util(ctx):
+    if ctx.out.get("point") is not None:
+        ctx.point = ctx.out["point"]
+        return ctx.point, None
+
+    op = ctx.op
+    options = ctx.options
+
+    allow_op = vs.getpath(options, "allow.op") or ""
+    if isinstance(allow_op, str) and op.name not in allow_op:
+        return None, ctx.make_error("point_op_allow",
+            'Operation "' + op.name +
+            '" not allowed by SDK option allow.op value: "' + allow_op + '"')
+
+    if len(op.points) == 0:
+        return None, ctx.make_error("point_no_points",
+            'Operation "' + op.name + '" has no endpoint definitions.')
+
+    if len(op.points) == 1:
+        ctx.point = op.points[0]
+    else:
+        if op.input == "data":
+            reqselector = ctx.reqdata
+            selector = ctx.data
+        else:
+            reqselector = ctx.reqmatch
+            selector = ctx.match
+
+        point = None
+        for i in range(len(op.points)):
+            point = op.points[i]
+            select_def = to_map(vs.getprop(point, "select"))
+            found = True
+
+            if selector is not None and select_def is not None:
+                exist = vs.getprop(select_def, "exist")
+                if isinstance(exist, list):
+                    for ek in exist:
+                        existkey = str(ek)
+                        rv = vs.getprop(reqselector, existkey)
+                        sv = vs.getprop(selector, existkey)
+                        if rv is None and sv is None:
+                            found = False
+                            break
+
+            if found:
+                req_action = vs.getprop(reqselector, "$action")
+                select_action = vs.getprop(select_def, "$action")
+                if req_action != select_action:
+                    found = False
+
+            if found:
+                break
+
+        if reqselector is not None:
+            req_action = vs.getprop(reqselector, "$action")
+            if req_action is not None and point is not None:
+                point_select = to_map(vs.getprop(point, "select"))
+                point_action = vs.getprop(point_select, "$action")
+                if req_action != point_action:
+                    return None, ctx.make_error("point_action_invalid",
+                        'Operation "' + op.name +
+                        '" action "' + vs.stringify(req_action) + '" is not valid.')
+
+        ctx.point = point
+
+    return ctx.point, None

package/project/.sdk/tm/py/utility/make_request.py

@@ -0,0 +1,52 @@
+# ProjectName SDK utility: make_request
+
+from __future__ import annotations
+from core.response import ProjectNameResponse
+from core.result import ProjectNameResult
+
+
+def make_request_util(ctx):
+    if ctx.out.get("request") is not None:
+        return ctx.out["request"], None
+
+    spec = ctx.spec
+    utility = ctx.utility
+
+    response = ProjectNameResponse({})
+    result = ProjectNameResult({})
+    ctx.result = result
+
+    if spec is None:
+        return None, ctx.make_error("request_no_spec",
+            "Expected context spec property to be defined.")
+
+    fetchdef, err = utility.make_fetch_def(ctx)
+    if err is not None:
+        response.err = err
+        ctx.response = response
+        spec.step = "postrequest"
+        return response, None
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["fetchdef"] = fetchdef
+
+    spec.step = "prerequest"
+
+    url = fetchdef.get("url", "")
+    fetched, fetch_err = utility.fetcher(ctx, url, fetchdef)
+
+    if fetch_err is not None:
+        response.err = fetch_err
+    elif fetched is None:
+        response = ProjectNameResponse({
+            "err": ctx.make_error("request_no_response", "response: undefined"),
+        })
+    elif isinstance(fetched, dict):
+        response = ProjectNameResponse(fetched)
+    else:
+        response.err = ctx.make_error("request_invalid_response", "response: invalid type")
+
+    spec.step = "postrequest"
+    ctx.response = response
+
+    return response, None

package/project/.sdk/tm/py/utility/make_response.py

@@ -0,0 +1,36 @@
+# ProjectName SDK utility: make_response
+
+
+def make_response_util(ctx):
+    if ctx.out.get("response") is not None:
+        return ctx.out["response"], None
+
+    utility = ctx.utility
+    spec = ctx.spec
+    result = ctx.result
+    response = ctx.response
+
+    if spec is None:
+        return None, ctx.make_error("response_no_spec",
+            "Expected context spec property to be defined.")
+    if response is None:
+        return None, ctx.make_error("response_no_response",
+            "Expected context response property to be defined.")
+    if result is None:
+        return None, ctx.make_error("response_no_result",
+            "Expected context result property to be defined.")
+
+    spec.step = "response"
+
+    utility.result_basic(ctx)
+    utility.result_headers(ctx)
+    utility.result_body(ctx)
+    utility.transform_response(ctx)
+
+    if result.err is None:
+        result.ok = True
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["result"] = result
+
+    return response, None

package/project/.sdk/tm/py/utility/make_result.py

@@ -0,0 +1,41 @@
+# ProjectName SDK utility: make_result
+
+
+def make_result_util(ctx):
+    if ctx.out.get("result") is not None:
+        return ctx.out["result"], None
+
+    utility = ctx.utility
+    op = ctx.op
+    entity = ctx.entity
+    spec = ctx.spec
+    result = ctx.result
+
+    if spec is None:
+        return None, ctx.make_error("result_no_spec",
+            "Expected context spec property to be defined.")
+    if result is None:
+        return None, ctx.make_error("result_no_result",
+            "Expected context result property to be defined.")
+
+    spec.step = "result"
+
+    utility.transform_response(ctx)
+
+    if op.name == "list":
+        resdata = result.resdata
+        result.resdata = []
+
+        if resdata is not None and isinstance(resdata, list) and entity is not None:
+            entities = []
+            for entry in resdata:
+                ent = entity.make()
+                if isinstance(entry, dict):
+                    ent.data_set(entry)
+                entities.append(ent)
+            result.resdata = entities
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["result"] = result
+
+    return result, None

package/project/.sdk/tm/py/utility/make_spec.py

@@ -0,0 +1,68 @@
+# ProjectName SDK utility: make_spec
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.spec import ProjectNameSpec
+
+
+def make_spec_util(ctx):
+    if ctx.out.get("spec") is not None:
+        ctx.spec = ctx.out["spec"]
+        return ctx.spec, None
+
+    point = ctx.point
+    options = ctx.options
+    utility = ctx.utility
+
+    base = ""
+    b = vs.getprop(options, "base")
+    if isinstance(b, str):
+        base = b
+
+    prefix = ""
+    p = vs.getprop(options, "prefix")
+    if isinstance(p, str):
+        prefix = p
+
+    suffix = ""
+    s = vs.getprop(options, "suffix")
+    if isinstance(s, str):
+        suffix = s
+
+    parts = []
+    if point is not None:
+        pt = vs.getprop(point, "parts")
+        if isinstance(pt, list):
+            parts = pt
+
+    ctx.spec = ProjectNameSpec({
+        "base": base,
+        "prefix": prefix,
+        "parts": parts,
+        "suffix": suffix,
+        "step": "start",
+    })
+
+    ctx.spec.method = utility.prepare_method(ctx)
+
+    allow_method = vs.getpath(options, "allow.method") or ""
+    if isinstance(allow_method, str) and ctx.spec.method not in allow_method:
+        return None, ctx.make_error("spec_method_allow",
+            'Method "' + ctx.spec.method +
+            '" not allowed by SDK option allow.method value: "' + allow_method + '"')
+
+    ctx.spec.params = utility.prepare_params(ctx)
+    ctx.spec.query = utility.prepare_query(ctx)
+    ctx.spec.headers = utility.prepare_headers(ctx)
+    ctx.spec.body = utility.prepare_body(ctx)
+    ctx.spec.path = utility.prepare_path(ctx)
+
+    if ctx.ctrl.explain is not None:
+        ctx.ctrl.explain["spec"] = ctx.spec
+
+    spec, err = utility.prepare_auth(ctx)
+    if err is not None:
+        return None, err
+
+    ctx.spec = spec
+    return spec, None

package/project/.sdk/tm/py/utility/make_url.py

@@ -0,0 +1,34 @@
+# ProjectName SDK utility: make_url
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def make_url_util(ctx):
+    spec = ctx.spec
+    result = ctx.result
+
+    if spec is None:
+        return "", ctx.make_error("url_no_spec",
+            "Expected context spec property to be defined.")
+    if result is None:
+        return "", ctx.make_error("url_no_result",
+            "Expected context result property to be defined.")
+
+    url = vs.join([spec.base, spec.prefix, spec.path, spec.suffix], "/", True)
+    resmatch = {}
+
+    param_items = vs.items(spec.params)
+    if param_items is not None:
+        for item in param_items:
+            key = item[0]
+            val = item[1]
+            if val is not None and isinstance(key, str):
+                val_str = val if isinstance(val, str) else str(val)
+                encoded = vs.escurl(val_str)
+                url = url.replace("{" + key + "}", encoded)
+                resmatch[key] = val
+
+    result.resmatch = resmatch
+
+    return url, None

package/project/.sdk/tm/py/utility/param.py

@@ -0,0 +1,55 @@
+# ProjectName SDK utility: param
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.helpers import to_map
+
+
+def param_util(ctx, paramdef):
+    point = ctx.point
+    spec = ctx.spec
+    match = ctx.match
+    reqmatch = ctx.reqmatch
+    data = ctx.data
+    reqdata = ctx.reqdata
+
+    pt = vs.typify(paramdef)
+    key = ""
+
+    if (vs.T_string & pt) > 0:
+        key = paramdef
+    else:
+        k = vs.getprop(paramdef, "name")
+        if isinstance(k, str):
+            key = k
+
+    akey = ""
+    if point is not None:
+        alias = to_map(vs.getprop(point, "alias"))
+        if alias is not None:
+            ak = vs.getprop(alias, key)
+            if isinstance(ak, str):
+                akey = ak
+
+    val = vs.getprop(reqmatch, key)
+
+    if val is None:
+        val = vs.getprop(match, key)
+
+    if val is None and akey != "":
+        if spec is not None:
+            spec.alias[akey] = key
+        val = vs.getprop(reqmatch, akey)
+
+    if val is None:
+        val = vs.getprop(reqdata, key)
+
+    if val is None:
+        val = vs.getprop(data, key)
+
+    if val is None and akey != "":
+        val = vs.getprop(reqdata, akey)
+        if val is None:
+            val = vs.getprop(data, akey)
+
+    return val

package/project/.sdk/tm/py/utility/prepare_auth.py

@@ -0,0 +1,34 @@
+# ProjectName SDK utility: prepare_auth
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+HEADER_AUTH = "authorization"
+OPTION_APIKEY = "apikey"
+NOT_FOUND = "__NOTFOUND__"
+
+
+def prepare_auth_util(ctx):
+    spec = ctx.spec
+    if spec is None:
+        return None, ctx.make_error("auth_no_spec",
+            "Expected context spec property to be defined.")
+
+    headers = spec.headers
+    options = ctx.client.options_map()
+
+    apikey = vs.getprop(options, OPTION_APIKEY, NOT_FOUND)
+
+    if isinstance(apikey, str) and apikey == NOT_FOUND:
+        headers.pop(HEADER_AUTH, None)
+    else:
+        auth_prefix = ""
+        ap = vs.getpath(options, "auth.prefix")
+        if isinstance(ap, str):
+            auth_prefix = ap
+        apikey_val = ""
+        if isinstance(apikey, str):
+            apikey_val = apikey
+        headers[HEADER_AUTH] = auth_prefix + " " + apikey_val
+
+    return spec, None

package/project/.sdk/tm/py/utility/prepare_body.py

@@ -0,0 +1,11 @@
+# ProjectName SDK utility: prepare_body
+
+
+def prepare_body_util(ctx):
+    op = ctx.op
+
+    if op.input == "data":
+        body = ctx.utility.transform_request(ctx)
+        return body
+
+    return None

package/project/.sdk/tm/py/utility/prepare_headers.py

@@ -0,0 +1,17 @@
+# ProjectName SDK utility: prepare_headers
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def prepare_headers_util(ctx):
+    options = ctx.client.options_map()
+    headers = vs.getprop(options, "headers")
+
+    if headers is None:
+        return {}
+
+    out = vs.clone(headers)
+    if isinstance(out, dict):
+        return out
+    return {}

package/project/.sdk/tm/py/utility/prepare_method.py

@@ -0,0 +1,15 @@
+# ProjectName SDK utility: prepare_method
+
+METHOD_MAP = {
+    "create": "POST",
+    "update": "PUT",
+    "load": "GET",
+    "list": "GET",
+    "remove": "DELETE",
+    "patch": "PATCH",
+}
+
+
+def prepare_method_util(ctx):
+    opname = ctx.op.name
+    return METHOD_MAP.get(opname, "GET")

package/project/.sdk/tm/py/utility/prepare_params.py

@@ -0,0 +1,28 @@
+# ProjectName SDK utility: prepare_params
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def prepare_params_util(ctx):
+    utility = ctx.utility
+    point = ctx.point
+
+    params = []
+    if point is not None:
+        args = vs.getprop(point, "args")
+        if isinstance(args, dict):
+            p = vs.getprop(args, "params")
+            if isinstance(p, list):
+                params = p
+
+    out = {}
+    for pd in params:
+        val = utility.param(ctx, pd)
+        if val is not None:
+            if isinstance(pd, dict):
+                name = vs.getprop(pd, "name")
+                if isinstance(name, str) and name != "":
+                    out[name] = val
+
+    return out

package/project/.sdk/tm/py/utility/prepare_path.py

@@ -0,0 +1,16 @@
+# ProjectName SDK utility: prepare_path
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def prepare_path_util(ctx):
+    point = ctx.point
+
+    parts = []
+    if point is not None:
+        p = vs.getprop(point, "parts")
+        if isinstance(p, list):
+            parts = p
+
+    return vs.join(parts, "/", True)

package/project/.sdk/tm/py/utility/prepare_query.py

@@ -0,0 +1,33 @@
+# ProjectName SDK utility: prepare_query
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+def _contains_param(params, s):
+    for v in params:
+        if isinstance(v, str) and v == s:
+            return True
+    return False
+
+
+def prepare_query_util(ctx):
+    point = ctx.point
+    reqmatch = ctx.reqmatch or {}
+
+    params = []
+    if point is not None:
+        p = vs.getprop(point, "params")
+        if isinstance(p, list):
+            params = p
+
+    out = {}
+    reqmatch_items = vs.items(reqmatch)
+    if reqmatch_items is not None:
+        for item in reqmatch_items:
+            key = item[0]
+            val = item[1]
+            if val is not None and isinstance(key, str) and not _contains_param(params, key):
+                out[key] = val
+
+    return out

package/project/.sdk/tm/py/utility/register.py

@@ -0,0 +1,68 @@
+# ProjectName SDK utility registration
+
+from core.utility_type import ProjectNameUtility
+
+from utility.clean import clean_util
+from utility.done import done_util
+from utility.make_error import make_error_util
+from utility.feature_add import feature_add_util
+from utility.feature_hook import feature_hook_util
+from utility.feature_init import feature_init_util
+from utility.fetcher import fetcher_util
+from utility.make_fetch_def import make_fetch_def_util
+from utility.make_context import make_context_util
+from utility.make_options import make_options_util
+from utility.make_request import make_request_util
+from utility.make_response import make_response_util
+from utility.make_result import make_result_util
+from utility.make_point import make_point_util
+from utility.make_spec import make_spec_util
+from utility.make_url import make_url_util
+from utility.param import param_util
+from utility.prepare_auth import prepare_auth_util
+from utility.prepare_body import prepare_body_util
+from utility.prepare_headers import prepare_headers_util
+from utility.prepare_method import prepare_method_util
+from utility.prepare_params import prepare_params_util
+from utility.prepare_path import prepare_path_util
+from utility.prepare_query import prepare_query_util
+from utility.result_basic import result_basic_util
+from utility.result_body import result_body_util
+from utility.result_headers import result_headers_util
+from utility.transform_request import transform_request_util
+from utility.transform_response import transform_response_util
+
+
+def register_all(u):
+    u.clean = clean_util
+    u.done = done_util
+    u.make_error = make_error_util
+    u.feature_add = feature_add_util
+    u.feature_hook = feature_hook_util
+    u.feature_init = feature_init_util
+    u.fetcher = fetcher_util
+    u.make_fetch_def = make_fetch_def_util
+    u.make_context = make_context_util
+    u.make_options = make_options_util
+    u.make_request = make_request_util
+    u.make_response = make_response_util
+    u.make_result = make_result_util
+    u.make_point = make_point_util
+    u.make_spec = make_spec_util
+    u.make_url = make_url_util
+    u.param = param_util
+    u.prepare_auth = prepare_auth_util
+    u.prepare_body = prepare_body_util
+    u.prepare_headers = prepare_headers_util
+    u.prepare_method = prepare_method_util
+    u.prepare_params = prepare_params_util
+    u.prepare_path = prepare_path_util
+    u.prepare_query = prepare_query_util
+    u.result_basic = result_basic_util
+    u.result_body = result_body_util
+    u.result_headers = result_headers_util
+    u.transform_request = transform_request_util
+    u.transform_response = transform_response_util
+
+
+ProjectNameUtility._registrar = register_all

package/project/.sdk/tm/py/utility/result_basic.py

@@ -0,0 +1,26 @@
+# ProjectName SDK utility: result_basic
+
+
+def result_basic_util(ctx):
+    response = ctx.response
+    result = ctx.result
+
+    if result is not None and response is not None:
+        result.status = response.status
+        result.status_text = response.status_text
+
+        if result.status >= 400:
+            msg = "request: " + str(result.status) + ": " + result.status_text
+            if result.err is not None:
+                prevmsg = ""
+                if hasattr(result.err, "msg") and result.err.msg is not None:
+                    prevmsg = result.err.msg
+                else:
+                    prevmsg = str(result.err)
+                result.err = ctx.make_error("request_status", prevmsg + ": " + msg)
+            else:
+                result.err = ctx.make_error("request_status", msg)
+        elif response.err is not None:
+            result.err = response.err
+
+    return result

package/project/.sdk/tm/py/utility/result_body.py

@@ -0,0 +1,13 @@
+# ProjectName SDK utility: result_body
+
+
+def result_body_util(ctx):
+    response = ctx.response
+    result = ctx.result
+
+    if result is not None:
+        if response is not None and response.json_func is not None and response.body is not None:
+            json_data = response.json_func()
+            result.body = json_data
+
+    return result

package/project/.sdk/tm/py/utility/result_headers.py

@@ -0,0 +1,17 @@
+# ProjectName SDK utility: result_headers
+
+
+def result_headers_util(ctx):
+    response = ctx.response
+    result = ctx.result
+
+    if result is not None:
+        if response is not None and response.headers is not None:
+            if isinstance(response.headers, dict):
+                result.headers = response.headers
+            else:
+                result.headers = {}
+        else:
+            result.headers = {}
+
+    return result

package/project/.sdk/tm/py/utility/transform_request.py

@@ -0,0 +1,27 @@
+# ProjectName SDK utility: transform_request
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.helpers import to_map
+
+
+def transform_request_util(ctx):
+    spec = ctx.spec
+    point = ctx.point
+
+    if spec is not None:
+        spec.step = "reqform"
+
+    transform = to_map(vs.getprop(point, "transform"))
+    if transform is None:
+        return ctx.reqdata
+
+    reqform = vs.getprop(transform, "req")
+    if reqform is None:
+        return ctx.reqdata
+
+    reqdata = vs.transform({
+        "reqdata": ctx.reqdata,
+    }, reqform)
+
+    return reqdata