@voxgig/create-sdkgen 0.0.1 → 0.0.3

package/tm/standard/src/php/Test_php.ts

@@ -0,0 +1,21 @@
+
+import { cmp, File, Content, Folder } from '@voxgig/sdkgen'
+
+import { Quick } from './Quick_php'
+import { TestMain } from './TestMain_php'
+
+
+const Test = cmp(function Test(props: any) {
+  const { build } = props
+
+  Folder({ name: 'test' }, () => {
+
+    Quick({ build })
+    TestMain({ build })
+  })
+})
+
+
+export {
+  Test
+}

package/tm/standard/src/py/Entity_py.ts

@@ -0,0 +1,98 @@
+
+import { cmp, File, Content, Folder } from '@voxgig/sdkgen'
+
+
+const Entity = cmp(function Entity(props: any) {
+  const { build, entity } = props
+  const { model } = props.ctx$
+
+  // console.log('build.name: ', entity.Name, build.name)
+
+  Folder({ name: 'src/' + model.name + '_sdk' }, () => {
+
+    File({ name: entity.Name + '.' + build.extension }, () => {
+
+      Content(`
+
+# from pydantic import BaseModel
+# from .Model import Data
+
+# ${model.Name} ${build.Name} ${entity.Name}
+
+class ${entity.Name}:
+    def __init__(self, sdk, data = {}):
+        self.sdk = sdk
+        self.definition = {
+          'name': '${entity.name}'
+        }
+        self.id = data.get('id') or ''
+        self.data = data
+
+    def handle_result(self, op, res, spec, handler):
+        status = res['status']
+        if(200 == status):
+            json = res['json']
+
+            return handler(json)
+        else:
+            raise Exception('HTTP-ERROR: ' + op + ' ${entity.name}: ' + str(status))
+
+    def create(self, data):
+        op = 'create'
+        self.data = data
+        # TODO: validate data
+
+        spec = self.sdk.fetchSpec(op, self)
+        res = self.sdk.options.fetch(spec['url'], spec)
+
+        return self.handle_result(op, res, spec, lambda json: json)
+
+    def save(self, data):
+        op = 'save'
+        self.data = data
+        # TODO: validate data
+
+        spec = self.sdk.fetchSpec(op, self)
+        res = self.sdk.options.fetch(spec['url'], spec)
+
+        return self.handle_result(op, res, spec, lambda json: json)
+
+    def load(self, data):
+        op = 'load'
+        self.data = data
+        # TODO: validate data
+
+        spec = self.sdk.fetchSpec(op, self)
+        res = self.sdk.options.fetch(spec['url'], spec)
+
+        return self.handle_result(op, res, spec, lambda json: json)
+
+    def list(self, data = {}):
+        op = 'list'
+        self.data = data
+        # TODO: validate data
+
+        spec = self.sdk.fetchSpec(op, self)
+        res = self.sdk.options.fetch(spec['url'], spec)
+
+        return self.handle_result(op, res, spec, lambda json: json)
+
+    def remove(self, data):
+        op = 'remove'
+        self.data = data
+        # TODO: validate data
+
+        spec = self.sdk.fetchSpec(op, self)
+        res = self.sdk.options.fetch(spec['url'], spec)
+
+        return self.handle_result(op, res, spec, lambda json: json)
+
+`)
+    })
+  })
+})
+
+
+export {
+  Entity
+}

package/tm/standard/src/py/MainEntity_py.ts

@@ -0,0 +1,19 @@
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+const MainEntity = cmp(async function MainEntity(props: any) {
+  const { entity } = props
+
+  const def = JSON.stringify(entity)
+
+  Content(`
+    def ${entity.Name}(self):
+        return ${entity.Name}(self, json.loads('''${def}'''))
+`)
+
+})
+
+
+export {
+  MainEntity
+}

package/tm/standard/src/py/Main_py.ts

@@ -0,0 +1,211 @@
+
+
+import { cmp, each, camelify, File, Content, Folder, Copy } from '@voxgig/sdkgen'
+
+import { MainEntity } from './MainEntity_py'
+import { Test } from './Test_py'
+
+
+const config_setup_files = [
+  'setup.py',
+  'pyproject.toml',
+  'requirements.txt',
+  'setup.cfg',
+  'MANIFEST.in',
+  'Makefile',
+  'pytest.ini'
+]
+
+const Main = cmp(async function Main(props: any) {
+  const { build, ctx$: { model } } = props
+
+  const entity = model.main.sdk.entity
+
+
+  Test({ build })
+
+  for (let config_file of config_setup_files) {
+    Copy({ from: 'tm/' + build.name + '/' + config_file, name: config_file })
+  }
+
+  File({ name: '.env.test.local' }, () => {
+    Content(`
+${model.Name}_ENDPOINT=example.com
+${model.Name}_ENDPOINT_PRISM=http://127.0.0.1:4010/a/b/c
+${model.Name}_APIKEY=pqapikey
+`)
+
+  })
+
+  Folder({ name: 'src/' + model.name + '_sdk' }, () => {
+
+    File({ name: '__init__.py' }, () => {
+      Content(`from .${model.Name}SDK import *
+from .Model import Config
+from .Model import Data
+from .Model import Query
+
+`)
+
+      each(entity, (entity: any) => {
+        entity.Name = camelify(entity.name)
+        // console.log('entity.Name: ', entity)
+        Content(`from .${entity.Name} import ${entity.Name}
+`)
+
+      })
+
+      Content(`__doc__ = 'An example SDK'
+`)
+
+
+    })
+
+    File({ name: 'Model.py' }, () => {
+      Content(`
+from typing import Any, Callable
+
+from pydantic import BaseModel, Field, ConfigDict, ValidationError
+
+
+class Config(BaseModel):
+    endpoint: str = Field(validate_default=True)
+    apikey: str = Field(validate_default=True)
+    fetch: Callable = Field(validate_default=True)
+
+    model_config = ConfigDict(extra='allow')
+
+class Data(BaseModel):
+    id: str = Field(default=None, validate_default=False)
+    model_config = ConfigDict(extra='allow')
+
+class Query(BaseModel):
+    id: str = Field(default=None, validate_default=False)
+    model_config = ConfigDict(extra='allow')
+
+`)
+
+    })
+
+
+    File({ name: model.Name + 'SDK.' + build.extension }, () => {
+
+      /*
+      const validate_options = each(build.options)
+        .reduce((a: string, opt: any) =>
+          a + ('String' === opt.kind ?
+            `        required(str, '${opt.name}', options)\n` : ''), '')
+      */
+
+      const imports = `
+import json
+
+`
+      Content(`${imports}`)
+
+      each(entity, (entity: any) => {
+        entity.Name = camelify(entity.name)
+        Content(`from .${entity.Name} import ${entity.Name}
+`)
+      })
+
+
+      /*
+      // Replaced by pydantic
+      Content(`
+def required(type_class, name, options):
+    val = options[name]
+    if(type_class != type(val)):
+        raise Exception('${model.Name}SDK: Invalid option: '+name+'='+val+': must be of type '+ str(type_class))
+
+`)
+*/
+
+      Content(`
+
+from pydantic import BaseModel
+# from .Model import Data
+
+# ${model.Name} ${build.Name} SDK
+
+
+class ${model.Name}SDK:
+    def __init__(self, options):
+        self.options = options
+
+
+    @staticmethod
+    def make(options):
+        return ${model.Name}SDK(options)
+
+    def endpoint(self, op, ent):
+        data = ent.data
+        id = None
+        # print("ent.data: ", type(ent.data) == Data, isinstance(ent.data, Data), isinstance(ent.data, BaseModel))
+        if dict == type(ent.data):
+            id = ent.data.get('id')
+        elif isinstance(ent.data, BaseModel):
+            id = ent.data.id
+
+        return (
+            self.options.endpoint
+            + "/"
+            + ent.definition.get("name")
+            + ((id and (op == 'load' or op == 'delete') and "/" + id) or "")
+        )
+
+    def method(self, op, ent=None):
+        key = op
+        if (None == ent or None == ent.id) and "save" == op:
+            key = "create"
+
+        if "create" == key:
+            return "POST"
+        elif "save" == key:
+            return "PUT"
+        elif "load" == key or "list" == key:
+            return "GET"
+        elif "remove" == key:
+            return "DELETE"
+
+    def body(self, op, ent):
+        # msg = {}
+        # msg.update(ent.data)
+        # print('body ent.data: ', ent.data)
+
+        if dict == type(ent.data):
+            # return json.dumps(ent.data)
+            return ent.data
+        elif isinstance(ent.data, BaseModel):
+            return ent.data.model_dump(exclude_none=True)
+            # return ent.data.model_dump_json(exclude_none=True)
+
+
+    def fetchSpec(self, op, ent):
+        method = self.method(op, ent)
+        spec = {
+            "url": self.endpoint(op, ent),
+            "method": method,
+            "headers": {
+                "content-type": "application/json",
+                "authorization": "Bearer " + self.options.apikey,
+            },
+            "body": ("GET" == method and {}) or self.body(op, ent),
+        }
+        return spec
+
+`)
+
+      each(entity, (entity: any) => {
+        MainEntity({ model, build, entity })
+      })
+
+
+    })
+  })
+})
+
+
+export {
+  Main
+}

package/tm/standard/src/py/Quick_py.ts

@@ -0,0 +1,133 @@
+
+import { cmp, File, Content } from '@voxgig/sdkgen'
+
+
+const Quick = cmp(function Quick(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+  File({ name: 'quick.' + build.extension }, () => {
+
+    Content(`
+from pathlib import Path
+import sys
+import json
+
+import requests
+from dotenv import dotenv_values
+
+path_root = str(Path(__file__).parents[1]) + '/src' + '/${model.name}_sdk'
+print('path_root: ', path_root)
+sys.path.append(path_root)
+
+import ${model.name}_sdk
+import ${model.name}_sdk.Model as Model
+from ${model.name}_sdk.Model import Data
+from ${model.name}_sdk.Model import Query
+
+# from Fetch import fetch
+
+config = dotenv_values("../.env.test.local")
+
+
+print("config: ", config, Model)
+
+
+print(${model.name}_sdk.${model.Name}SDK)
+print(dir(${model.name}_sdk))
+
+def fetch(url, config):
+
+    method = config.get('method') or 'GET'
+    headers = config.get('headers') or {}
+    body = config.get('body') or {}
+
+    res = None
+
+    if method == 'GET':
+        res = requests.get(url, headers=headers)
+
+    elif method == 'POST':
+        res = requests.post(url, headers=headers, json=body)
+    elif method == 'PUT':
+        res = requests.put(url, headers=headers, json=body)
+
+
+    if res.status_code >= 200 and res.status_code < 300:
+        return { "status": res.status_code, "json": res.json(), "res": res }
+
+    return { "status": res.status_code }
+
+
+if __name__ == "__main__":
+    client = ${model.name}_sdk.${model.Name}SDK.make(Model.Config(
+        endpoint=config.get('${model.NAME}_ENDPOINT_PRISM'),
+        apikey=config.get('${model.NAME}_APIKEY'),
+        fetch=fetch
+    ))
+
+    # load
+    out = client.Geofence().load({"id": "CF49B47C-317B-4387-83C3-4A23715B1C45"})
+    print("Geofence.load", out)
+
+    # or
+    out = client.Geofence().load(Query(id="CF49B47C-317B-4387-83C3-4A23715B1C45"))
+    print("Geofence.load", out)
+
+    # list
+    out = client.Geofence().list()
+    print("Geofence.list: ", out)
+
+    # create
+    out = client.Geofence().create(Data(
+      id='CF49B47C-317B-4387-83C3-4A23715B1C45',
+      name='Geofence 1',
+      desc='Geofence 1 description',
+      custom={ 'foo': 'bar' },
+      extent_id='CF49B47C-317B-4387-83C3-4A23715B1C45'
+    ))
+
+    print('Geofence.create: ', out)
+
+    # save
+    out = client.Geofence().save(Data(
+      id='CF49B47C-317B-4387-83C3-4A23715B1C45',
+      name='Geofence 1',
+      desc='Geofence 1 description',
+      custom={ 'foo': 'bar' },
+      extent_id='CF49B47C-317B-4387-83C3-4A23715B1C45'
+    ))
+
+    print('Geofence.save: ', out)
+
+    '''
+    # create
+    out = client.Geofence().create(Data(
+        title="T04",
+        area=0,
+    ))
+    print("Geofence.create: ", out)
+
+    # or
+    out = client.Geofence().create({
+        "title": "T05",
+        "area": 0
+    })
+    print("Geofence.create: ", out)
+    '''
+
+    # remove
+    out = client.Geofence().remove({"id": "CF49B47C-317B-4387-83C3-4A23715B1C45"})
+    print("Geofence.remove: ", out)
+
+
+
+`)
+
+  })
+})
+
+
+export {
+  Quick
+}

package/tm/standard/src/py/TestAcceptEntity_py.ts

@@ -0,0 +1,47 @@
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestAcceptEntity = cmp(function TestAcceptEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  Content(`
+def test_${entity.name}_load():
+    config = dotenv_values('.env.test.local')
+    client = makeClient(config)
+    out = client.${entity.Name}().load({"id" :'t01'})
+
+    expectedFormat = {
+      'id': str,
+      'name': str,
+      'desc': str,
+      'custom': dict,
+    }
+
+    print('load', out)
+
+    for key in expectedFormat:
+        assert expectedFormat[key] == type(out[key])
+
+
+`);
+
+  Content(`
+def test_${entity.name}_list():
+    config = dotenv_values('.env.test.local')
+    client = makeClient(config)
+    out = client.${entity.Name}().list()
+
+    print('list', out)
+    assert out['name'] == '${entity.name}' and len(out['list']) > 0
+
+`);
+
+
+})
+
+
+export {
+  TestAcceptEntity
+}

package/tm/standard/src/py/TestAccept_py.ts

@@ -0,0 +1,77 @@
+import { cmp, each, File, Content } from '@voxgig/sdkgen'
+
+
+import { TestAcceptEntity } from './TestAcceptEntity_py'
+
+
+const TestAccept = cmp(function TestAccept(props: any) {
+  const { build } = props
+  const { model } = props.ctx$
+
+
+  File({ name: 'test_accept_' + model.Name + '.' + build.extension }, () => {
+
+    Content(`
+from pathlib import Path
+import sys
+path_root = str(Path(__file__).parents[1])
+sys.path.append(path_root)
+
+import json
+
+import requests
+from dotenv import dotenv_values
+
+import ${model.name}_sdk
+
+from ${model.name}_sdk import Config
+
+# from Fetch import fetch
+
+def fetch(url, config):
+
+    method = config.get('method') or 'GET'
+    headers = config.get('headers') or {}
+    body = config.get('body') or {}
+
+    res = None
+
+    if method == 'GET':
+        res = requests.get(url, headers=headers)
+    elif method == 'POST':
+        res = requests.post(url, headers=headers, json=body)
+    elif method == 'PUT':
+        res = requests.put(url, headers=headers, json=body)
+
+
+    if res.status_code >= 200 and res.status_code < 300:
+        return { "status": res.status_code, "json": res.json(), "res": res }
+
+    return { "status": res.status_code }
+
+def makeClient(config = {}):
+    client = ${model.name}_sdk.${model.Name}SDK.make(Config(
+        endpoint=config.get('${model.NAME}_ENDPOINT_PRISM'),
+        apikey=config.get('${model.NAME}_APIKEY') or 'abc123',
+        fetch=fetch
+    ))
+    return client
+
+
+def test_happy():
+    config = dotenv_values('.env.test.local')
+    client = makeClient(config)
+`)
+
+    each(model.main.sdk.entity, (entity: any) => {
+      TestAcceptEntity({ model, build, entity })
+    })
+
+  })
+})
+
+
+export {
+  TestAccept
+}
+

package/tm/standard/src/py/TestEntity_py.ts

@@ -0,0 +1,50 @@
+
+import { cmp, camelify, Content } from '@voxgig/sdkgen'
+
+
+const TestEntity = cmp(function TestEntity(props: any) {
+  const { entity } = props
+
+  entity.Name = camelify(entity.name)
+
+  // console.log(entity.op)
+
+  // TODO: refactor via loop
+  for (let key in entity.op) {
+    // console.log(key)
+  }
+
+  Content(`
+def test_${entity.name}():
+    config = dotenv_values('.env.test.local')
+    client = makeClient(config)
+
+    # create
+    out = client.${entity.Name}().create({ 'title': 'T03' })
+    print('create', out)
+    assert out == {'id': 'n03', 'title': 'T03'}
+
+    # save
+    out = client.${entity.Name}().save({ 'id': 'n03', 'title': 'T03_3'})
+    print('save', out)
+    assert out == { 'id': 'n03', 'title': 'T03_3' }
+
+    # load
+    out = client.${entity.Name}().load({ 'id': 't01' })
+    print('load', out)
+    assert out == {'id': 't01', 'title': 'T01'}
+
+    # list
+    out = client.${entity.Name}().list()
+    assert out['list'] != None and len(out['list']) != 0
+    assert out['name'] == "${entity.name}"
+    print('list', out)
+    # raise Exception('4')
+
+`)
+})
+
+
+export {
+  TestEntity
+}