@voxgig/sdkgen 0.35.2 → 0.37.0

package/project/.sdk/tm/py/Makefile

@@ -0,0 +1,10 @@
+.PHONY: test build clean
+
+test:
+	python -m pytest test/
+
+build:
+	@echo "No build step for Python"
+
+clean:
+	find . -name __pycache__ -exec rm -rf {} + 2>/dev/null; true

package/project/.sdk/tm/py/core/context.py

@@ -0,0 +1,199 @@
+# ProjectName SDK context
+
+from __future__ import annotations
+import random
+
+from utility.voxgig_struct import voxgig_struct as vs
+from core.control import ProjectNameControl
+from core.operation import ProjectNameOperation
+from core.spec import ProjectNameSpec
+from core.result import ProjectNameResult
+from core.response import ProjectNameResponse
+from core.error import ProjectNameError
+from core.helpers import get_ctx_prop, to_map
+
+
+class ProjectNameContext:
+    def __init__(self, ctxmap=None, basectx=None):
+        self.id = "C" + str(random.randint(10000000, 99999999))
+        self.out = {}
+
+        if ctxmap is None:
+            ctxmap = {}
+
+        # Client
+        c = get_ctx_prop(ctxmap, "client")
+        if c is not None:
+            self.client = c
+        elif basectx is not None:
+            self.client = basectx.client
+        else:
+            self.client = None
+
+        # Utility
+        u = get_ctx_prop(ctxmap, "utility")
+        if u is not None:
+            self.utility = u
+        elif basectx is not None:
+            self.utility = basectx.utility
+        else:
+            self.utility = None
+
+        # Ctrl
+        self.ctrl = ProjectNameControl()
+        ctrl_raw = get_ctx_prop(ctxmap, "ctrl")
+        if isinstance(ctrl_raw, dict):
+            if ctrl_raw.get("throw_err") is not None:
+                self.ctrl.throw_err = ctrl_raw["throw_err"]
+            elif isinstance(ctrl_raw.get("throw"), bool):
+                self.ctrl.throw_err = ctrl_raw["throw"]
+            if isinstance(ctrl_raw.get("explain"), dict):
+                self.ctrl.explain = ctrl_raw["explain"]
+        elif basectx is not None and basectx.ctrl is not None:
+            self.ctrl = basectx.ctrl
+
+        # Meta
+        self.meta = {}
+        m = get_ctx_prop(ctxmap, "meta")
+        if isinstance(m, dict):
+            self.meta = m
+        elif basectx is not None and basectx.meta is not None:
+            self.meta = basectx.meta
+
+        # Config
+        cfg = get_ctx_prop(ctxmap, "config")
+        if isinstance(cfg, dict):
+            self.config = cfg
+        elif basectx is not None:
+            self.config = basectx.config
+        else:
+            self.config = None
+
+        # Entopts
+        eo = get_ctx_prop(ctxmap, "entopts")
+        if isinstance(eo, dict):
+            self.entopts = eo
+        elif basectx is not None:
+            self.entopts = basectx.entopts
+        else:
+            self.entopts = None
+
+        # Options
+        o = get_ctx_prop(ctxmap, "options")
+        if isinstance(o, dict):
+            self.options = o
+        elif basectx is not None:
+            self.options = basectx.options
+        else:
+            self.options = None
+
+        # Entity
+        e = get_ctx_prop(ctxmap, "entity")
+        if e is not None:
+            self.entity = e
+        elif basectx is not None:
+            self.entity = basectx.entity
+        else:
+            self.entity = None
+
+        # Shared
+        s = get_ctx_prop(ctxmap, "shared")
+        if isinstance(s, dict):
+            self.shared = s
+        elif basectx is not None:
+            self.shared = basectx.shared
+        else:
+            self.shared = None
+
+        # Opmap
+        om = get_ctx_prop(ctxmap, "opmap")
+        if isinstance(om, dict):
+            self.opmap = om
+        elif basectx is not None:
+            self.opmap = basectx.opmap
+        else:
+            self.opmap = None
+        if self.opmap is None:
+            self.opmap = {}
+
+        # Data
+        self.data = to_map(get_ctx_prop(ctxmap, "data")) or {}
+        self.reqdata = to_map(get_ctx_prop(ctxmap, "reqdata")) or {}
+        self.match = to_map(get_ctx_prop(ctxmap, "match")) or {}
+        self.reqmatch = to_map(get_ctx_prop(ctxmap, "reqmatch")) or {}
+
+        # Point
+        pt = get_ctx_prop(ctxmap, "point")
+        if isinstance(pt, dict):
+            self.point = pt
+        elif basectx is not None:
+            self.point = basectx.point
+        else:
+            self.point = None
+
+        # Spec
+        sp = get_ctx_prop(ctxmap, "spec")
+        if isinstance(sp, ProjectNameSpec):
+            self.spec = sp
+        elif basectx is not None:
+            self.spec = basectx.spec
+        else:
+            self.spec = None
+
+        # Result
+        r = get_ctx_prop(ctxmap, "result")
+        if isinstance(r, ProjectNameResult):
+            self.result = r
+        elif basectx is not None:
+            self.result = basectx.result
+        else:
+            self.result = None
+
+        # Response
+        rp = get_ctx_prop(ctxmap, "response")
+        if isinstance(rp, ProjectNameResponse):
+            self.response = rp
+        elif basectx is not None:
+            self.response = basectx.response
+        else:
+            self.response = None
+
+        # Resolve operation
+        opname = get_ctx_prop(ctxmap, "opname") or ""
+        self.op = self.resolve_op(opname)
+
+    def resolve_op(self, opname):
+        if opname in self.opmap:
+            return self.opmap[opname]
+
+        if opname == "":
+            return ProjectNameOperation({})
+
+        entname = "_"
+        if self.entity is not None and hasattr(self.entity, "get_name") and callable(self.entity.get_name):
+            entname = self.entity.get_name()
+
+        opcfg = vs.getpath(self.config, "entity." + entname + ".op." + opname)
+
+        inpt = "match"
+        if opname == "update" or opname == "create":
+            inpt = "data"
+
+        points = []
+        if isinstance(opcfg, dict):
+            t = vs.getprop(opcfg, "points")
+            if isinstance(t, list):
+                points = t
+
+        op = ProjectNameOperation({
+            "entity": entname,
+            "name": opname,
+            "input": inpt,
+            "points": points,
+        })
+
+        self.opmap[opname] = op
+        return op
+
+    def make_error(self, code, msg):
+        return ProjectNameError(code, msg, self)

package/project/.sdk/tm/py/core/control.py

@@ -0,0 +1,12 @@
+# ProjectName SDK control
+
+from __future__ import annotations
+
+
+class ProjectNameControl:
+    def __init__(self, opts=None):
+        if opts is None:
+            opts = {}
+        self.throw_err = opts.get("throw_err")
+        self.err = None
+        self.explain = opts.get("explain")

package/project/.sdk/tm/py/core/error.py

@@ -0,0 +1,18 @@
+# ProjectName SDK error
+
+from __future__ import annotations
+
+
+class ProjectNameError(Exception):
+    def __init__(self, code="", msg="", ctx=None):
+        super().__init__(msg)
+        self.is_sdk_error = True
+        self.sdk = "ProjectName"
+        self.code = code
+        self.msg = msg
+        self.ctx = ctx
+        self.result = None
+        self.spec = None
+
+    def __str__(self):
+        return self.msg

package/project/.sdk/tm/py/core/helpers.py

@@ -0,0 +1,15 @@
+# ProjectName SDK helpers
+
+
+def to_map(v):
+    return v if isinstance(v, dict) else None
+
+
+def to_int(v):
+    return int(v) if isinstance(v, (int, float)) else -1
+
+
+def get_ctx_prop(m, key):
+    if m is None:
+        return None
+    return m.get(key) if isinstance(m, dict) else None

package/project/.sdk/tm/py/core/operation.py

@@ -0,0 +1,37 @@
+# ProjectName SDK operation
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+class ProjectNameOperation:
+    def __init__(self, opmap=None):
+        if opmap is None:
+            opmap = {}
+
+        entity = vs.getprop(opmap, "entity")
+        if not isinstance(entity, str) or entity == "":
+            entity = "_"
+        self.entity = entity
+
+        name = vs.getprop(opmap, "name")
+        if not isinstance(name, str) or name == "":
+            name = "_"
+        self.name = name
+
+        inpt = vs.getprop(opmap, "input")
+        if not isinstance(inpt, str) or inpt == "":
+            inpt = "_"
+        self.input = inpt
+
+        self.points = []
+        raw_points = vs.getprop(opmap, "points")
+        if isinstance(raw_points, list):
+            for t in raw_points:
+                if isinstance(t, dict):
+                    self.points.append(t)
+
+        self.alias = None
+        raw_alias = vs.getprop(opmap, "alias")
+        if isinstance(raw_alias, dict):
+            self.alias = raw_alias

package/project/.sdk/tm/py/core/response.py

@@ -0,0 +1,34 @@
+# ProjectName SDK response
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+class ProjectNameResponse:
+    def __init__(self, resmap=None):
+        if resmap is None:
+            resmap = {}
+
+        self.status = -1
+        s = vs.getprop(resmap, "status")
+        if s is not None and isinstance(s, (int, float)):
+            self.status = int(s)
+
+        self.status_text = ""
+        st = vs.getprop(resmap, "statusText")
+        if isinstance(st, str):
+            self.status_text = st
+
+        self.headers = vs.getprop(resmap, "headers")
+
+        self.json_func = None
+        jf = vs.getprop(resmap, "json")
+        if callable(jf):
+            self.json_func = jf
+
+        self.body = vs.getprop(resmap, "body")
+
+        self.err = None
+        e = vs.getprop(resmap, "err")
+        if e is not None:
+            self.err = e

package/project/.sdk/tm/py/core/result.py

@@ -0,0 +1,44 @@
+# ProjectName SDK result
+
+from __future__ import annotations
+from utility.voxgig_struct import voxgig_struct as vs
+
+
+class ProjectNameResult:
+    def __init__(self, resmap=None):
+        if resmap is None:
+            resmap = {}
+
+        self.ok = False
+        if vs.getprop(resmap, "ok") is True:
+            self.ok = True
+
+        self.status = -1
+        s = vs.getprop(resmap, "status")
+        if s is not None:
+            if isinstance(s, (int, float)):
+                self.status = int(s)
+
+        self.status_text = ""
+        st = vs.getprop(resmap, "statusText")
+        if isinstance(st, str):
+            self.status_text = st
+
+        self.headers = {}
+        h = vs.getprop(resmap, "headers")
+        if isinstance(h, dict):
+            self.headers = h
+
+        self.body = vs.getprop(resmap, "body")
+
+        self.err = None
+        e = vs.getprop(resmap, "err")
+        if e is not None:
+            self.err = e
+
+        self.resdata = vs.getprop(resmap, "resdata")
+
+        self.resmatch = None
+        rm = vs.getprop(resmap, "resmatch")
+        if isinstance(rm, dict):
+            self.resmatch = rm

package/project/.sdk/tm/py/core/spec.py

@@ -0,0 +1,23 @@
+# ProjectName SDK spec
+
+from __future__ import annotations
+
+
+class ProjectNameSpec:
+    def __init__(self, specmap=None):
+        if specmap is None:
+            specmap = {}
+
+        self.parts = specmap.get("parts", [])
+        self.headers = specmap.get("headers", {})
+        self.alias = specmap.get("alias", {})
+        self.base = specmap.get("base", "")
+        self.prefix = specmap.get("prefix", "")
+        self.suffix = specmap.get("suffix", "")
+        self.params = specmap.get("params", {})
+        self.query = specmap.get("query", {})
+        self.step = specmap.get("step", "")
+        self.method = specmap.get("method", "GET")
+        self.body = specmap.get("body")
+        self.url = specmap.get("url", "")
+        self.path = specmap.get("path", "")

package/project/.sdk/tm/py/core/utility_type.py

@@ -0,0 +1,82 @@
+# ProjectName SDK utility type
+
+from __future__ import annotations
+
+
+class ProjectNameUtility:
+    _registrar = None
+
+    def __init__(self):
+        self.custom = {}
+
+        # All utility functions are set by the register module
+        self.clean = None
+        self.done = None
+        self.make_error = None
+        self.feature_add = None
+        self.feature_hook = None
+        self.feature_init = None
+        self.fetcher = None
+        self.make_fetch_def = None
+        self.make_context = None
+        self.make_options = None
+        self.make_request = None
+        self.make_response = None
+        self.make_result = None
+        self.make_point = None
+        self.make_spec = None
+        self.make_url = None
+        self.param = None
+        self.prepare_auth = None
+        self.prepare_body = None
+        self.prepare_headers = None
+        self.prepare_method = None
+        self.prepare_params = None
+        self.prepare_path = None
+        self.prepare_query = None
+        self.result_basic = None
+        self.result_body = None
+        self.result_headers = None
+        self.transform_request = None
+        self.transform_response = None
+
+        # Let the registrar fill in all functions
+        if ProjectNameUtility._registrar is not None:
+            ProjectNameUtility._registrar(self)
+
+    @classmethod
+    def copy(cls, src):
+        u = cls()
+        u.clean = src.clean
+        u.done = src.done
+        u.make_error = src.make_error
+        u.feature_add = src.feature_add
+        u.feature_hook = src.feature_hook
+        u.feature_init = src.feature_init
+        u.fetcher = src.fetcher
+        u.make_fetch_def = src.make_fetch_def
+        u.make_context = src.make_context
+        u.make_options = src.make_options
+        u.make_request = src.make_request
+        u.make_response = src.make_response
+        u.make_result = src.make_result
+        u.make_point = src.make_point
+        u.make_spec = src.make_spec
+        u.make_url = src.make_url
+        u.param = src.param
+        u.prepare_auth = src.prepare_auth
+        u.prepare_body = src.prepare_body
+        u.prepare_headers = src.prepare_headers
+        u.prepare_method = src.prepare_method
+        u.prepare_params = src.prepare_params
+        u.prepare_path = src.prepare_path
+        u.prepare_query = src.prepare_query
+        u.result_basic = src.result_basic
+        u.result_body = src.result_body
+        u.result_headers = src.result_headers
+        u.transform_request = src.transform_request
+        u.transform_response = src.transform_response
+        u.custom = {}
+        for k, v in src.custom.items():
+            u.custom[k] = v
+        return u

package/project/.sdk/tm/py/feature/base_feature.py

@@ -0,0 +1,61 @@
+# ProjectName SDK base feature
+
+from __future__ import annotations
+
+
+class ProjectNameBaseFeature:
+    def __init__(self):
+        self.version = "0.0.1"
+        self.name = "base"
+        self.active = True
+
+    def get_version(self):
+        return self.version
+
+    def get_name(self):
+        return self.name
+
+    def get_active(self):
+        return self.active
+
+    def init(self, ctx, options):
+        pass
+
+    def PostConstruct(self, ctx):
+        pass
+
+    def PostConstructEntity(self, ctx):
+        pass
+
+    def SetData(self, ctx):
+        pass
+
+    def GetData(self, ctx):
+        pass
+
+    def GetMatch(self, ctx):
+        pass
+
+    def SetMatch(self, ctx):
+        pass
+
+    def PrePoint(self, ctx):
+        pass
+
+    def PreSpec(self, ctx):
+        pass
+
+    def PreRequest(self, ctx):
+        pass
+
+    def PreResponse(self, ctx):
+        pass
+
+    def PreResult(self, ctx):
+        pass
+
+    def PreDone(self, ctx):
+        pass
+
+    def PreUnexpected(self, ctx):
+        pass

package/project/.sdk/tm/py/feature/log_feature.py

@@ -0,0 +1,84 @@
+# ProjectName SDK log feature
+
+from __future__ import annotations
+import sys
+
+from feature.base_feature import ProjectNameBaseFeature
+
+
+class ProjectNameLogFeature(ProjectNameBaseFeature):
+    def __init__(self):
+        super().__init__()
+        self.version = "0.0.1"
+        self.name = "log"
+        self.active = True
+        self.client = None
+        self.options = None
+        self.logger = None
+
+    def init(self, ctx, options):
+        self.client = ctx.client
+        self.options = options
+
+        if options.get("active") is True:
+            self.active = True
+        else:
+            self.active = False
+
+        if self.active:
+            if isinstance(options.get("logger"), dict):
+                self.logger = options["logger"]
+            else:
+                self.logger = {
+                    "info": lambda msg, *a: sys.stderr.write("[INFO] " + msg + "\n"),
+                    "debug": lambda msg, *a: sys.stderr.write("[DEBUG] " + msg + "\n"),
+                    "warn": lambda msg, *a: sys.stderr.write("[WARN] " + msg + "\n"),
+                    "error": lambda msg, *a: sys.stderr.write("[ERROR] " + msg + "\n"),
+                }
+
+    def _loghook(self, hook, ctx, level="info"):
+        if self.logger is None:
+            return
+
+        opname = ""
+        if ctx.op is not None:
+            opname = ctx.op.name
+
+        msg = "hook=" + hook + " op=" + opname
+
+        log_fn = self.logger.get(level)
+        if callable(log_fn):
+            log_fn(msg)
+
+    def PostConstruct(self, ctx):
+        self._loghook("PostConstruct", ctx)
+
+    def PostConstructEntity(self, ctx):
+        self._loghook("PostConstructEntity", ctx)
+
+    def SetData(self, ctx):
+        self._loghook("SetData", ctx)
+
+    def GetData(self, ctx):
+        self._loghook("GetData", ctx)
+
+    def SetMatch(self, ctx):
+        self._loghook("SetMatch", ctx)
+
+    def GetMatch(self, ctx):
+        self._loghook("GetMatch", ctx)
+
+    def PrePoint(self, ctx):
+        self._loghook("PrePoint", ctx)
+
+    def PreSpec(self, ctx):
+        self._loghook("PreSpec", ctx)
+
+    def PreRequest(self, ctx):
+        self._loghook("PreRequest", ctx)
+
+    def PreResponse(self, ctx):
+        self._loghook("PreResponse", ctx)
+
+    def PreResult(self, ctx):
+        self._loghook("PreResult", ctx)