@voxgig/sdkgen 0.35.2 → 0.37.0

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

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

@@ -0,0 +1,39 @@
+# ProjectName SDK utility: transform_response
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+from core.helpers import to_map
+
+
+def transform_response_util(ctx):
+    spec = ctx.spec
+    result = ctx.result
+    point = ctx.point
+
+    if spec is not None:
+        spec.step = "resform"
+
+    if result is None or not result.ok:
+        return None
+
+    transform = to_map(vs.getprop(point, "transform"))
+    if transform is None:
+        return None
+
+    resform = vs.getprop(transform, "res")
+    if resform is None:
+        return None
+
+    resdata = vs.transform({
+        "ok": result.ok,
+        "status": result.status,
+        "statusText": result.status_text,
+        "headers": result.headers,
+        "body": result.body,
+        "err": result.err,
+        "resdata": result.resdata,
+        "resmatch": result.resmatch,
+    }, resform)
+
+    result.resdata = resdata
+    return resdata

package/project/.sdk/tm/py/utility/voxgig_struct/__init__.py

@@ -0,0 +1,72 @@
+# voxgig_struct init
+
+from .voxgig_struct import (
+    clone,
+    delprop,
+    escre,
+    escurl,
+    filter,
+    flatten,
+    getdef,
+    getelem,
+    getpath,
+    getprop,
+    haskey,
+    inject,
+    isempty,
+    isfunc,
+    iskey,
+    islist,
+    ismap,
+    isnode,
+    items,
+    ja,
+    jm,
+    jo,
+    join,
+    joinurl,
+    jsonify,
+    jt,
+    keysof,
+    merge,
+    pad,
+    pathify,
+    replace,
+    select,
+    setpath,
+    setprop,
+    size,
+    slice,
+    stringify,
+    strkey,
+    transform,
+    typename,
+    typify,
+    validate,
+    walk,
+    Injection,
+    StructUtility,
+    checkPlacement,
+    injectorArgs,
+    injectChild,
+    SKIP,
+    DELETE,
+    T_any,
+    T_noval,
+    T_boolean,
+    T_decimal,
+    T_integer,
+    T_number,
+    T_string,
+    T_function,
+    T_symbol,
+    T_null,
+    T_list,
+    T_map,
+    T_instance,
+    T_scalar,
+    T_node,
+    M_KEYPRE,
+    M_KEYPOST,
+    M_VAL,
+)