buildz 0.3.9__tar.gz → 0.4.1__tar.gz

{buildz-0.3.9/buildz.egg-info → buildz-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.3.9
+Version: 0.4.1
 Summary: a json-like file format's read and write code by python, and codes to read and product object from configure file in such format
 Home-page: https://github.com/buildCodeZ/buildz
 Author: Zzz

buildz-0.4.1/buildz/demo/ioc/test.py

@@ -0,0 +1,37 @@
+#
+from buildz.ioc import build
+from buildz import xf
+import os
+join = os.path.join
+class Test:
+    def __init__(self, *args, **maps):
+        print(f"Test init args: {args}, maps: {maps}")
+        self.args = args
+        self.maps = maps
+    def run(self):
+        print(f"get obj:{self}")
+        print("get_obj.obj:", self.obj)
+
+pass
+fps = xf.loads("[data1.js, data2.js, data3.js]")[:2]
+
+fps = [join('test_conf', fp) for fp in fps]
+def show():
+    print("run show")
+
+pass
+def test():
+    confs = build()
+    for fp in fps:
+        confs.add_fp(fp)
+    #obj =  confs.get("data1.test")
+    confs.get("data1.run")
+    obj = confs.get("data1.test.obj")
+    print(f"obj: {obj}")
+
+pass
+
+if __name__=="__main__":
+    test()
+
+pass

buildz-0.4.1/buildz/demo/ioc/test_conf/base.js

@@ -0,0 +1,9 @@
+
+{
+    env_spt: "." // split on env id
+    spt: "." // split on id
+    default_type: 'test' // default type of data
+    deep_first: false // 全局查id的时候是从最上层开始找还是从最下层开始找（每一层都可能有配置文件）
+    global_env: true //True=环境变量env都是全局的（全局查找），否则优先每个配置文件里查环境变量，查不到才查全局
+    global_deal: true //True=类型处理函数deal都是全局的（全局查找），否则优先每个配置文件里查处理函数，查不到才查全局
+}

buildz-0.4.1/buildz/demo/ioc/test_conf/data1.js

@@ -0,0 +1,43 @@
+{
+    envs: {
+        env.test: 123
+    }
+    namespace: data1
+    default_type: default
+    datas: [
+        {
+            id: test
+            type: object
+            source: test.Test
+            single: 1
+            construct: {
+                args: [
+                    [env, env.test]
+                    [val, 123]
+                ],
+                maps: {
+                    key:[ref, data2.test]
+                }
+            },
+            sets: [
+                [obj, [ref, test]]
+                [obj1, [ovar, null, args]]
+            ],
+            calls: [
+                [mcall, null, run, [], {}]
+            ]
+        }
+        {
+            id: run
+            type: mcall
+            source: test
+            method: run
+            args: []
+            maps: {}
+        }
+        {
+            id: test.obj
+            val: test.show
+        }
+    ]
+}

buildz-0.4.1/buildz/demo/ioc/test_conf/data2.js

@@ -0,0 +1,21 @@
+{
+    
+    namespace: data2
+    default_type: obj
+    datas: [
+        {
+            id: test
+            type: object
+            source: test.Test
+            construct: {
+                args: [
+                    [env, env.test]
+                    [env, path]
+                ]
+                maps: {
+                    
+                }
+            }
+        }
+    ]
+}

buildz-0.4.1/buildz/demo/ioc/test_conf/data3.js

@@ -0,0 +1,21 @@
+{
+    envs: {
+        env.name: "data3"
+    }
+    namespace: data3
+    default_type: obj
+    datas: [
+        {
+            id: test
+            type: obj
+            args: [1,2,3]
+            maps: {4:5,6:7}
+            ref: test1
+        }
+        {
+            id: test1
+            type: obj
+            args: ['no ref']
+        }
+    ]
+}

buildz-0.4.1/buildz/ioc/__init__.py

@@ -0,0 +1,3 @@
+#coding=utf-8
+
+from .init import build

buildz-0.4.1/buildz/ioc/init.py

@@ -0,0 +1,14 @@
+#
+
+from .ioc import confs
+from .ioc_deal.base import default_deals
+
+def build(fp_init = None, add_default_deals = True):
+    obj = confs.Confs()
+    if (fp_init is not None):
+        obj.init_fp(fp_init)
+    if add_default_deals:
+        obj.add_fp(default_deals)
+    return obj
+
+pass

buildz-0.4.1/buildz/ioc/ioc/base.py

@@ -0,0 +1,34 @@
+#coding=utf-8
+from buildz import xf, pyz
+from buildz.xf import g as xg
+import json
+class Base:
+    def update_maps(self, maps, src):
+        xf.deep_update(maps, src)
+    def __init__(self, *args, **maps):
+        self.init(*args, **maps)
+    def init(self, *args, **maps):
+        pass
+    def __call__(self, *args, **maps):
+        return self.deal(*args, **maps)
+    def deal(self, *args, **maps):
+        return None
+
+pass
+class EncapeData(Base):
+    """
+        包含data id对应的配置，配置文件id，配置文件对象
+        [object.test, call, ]
+    """
+    def __init__(self, data, conf, local = False, type = None, src = None):
+        self.data = data
+        self.sid = conf.id
+        self.src = src
+        self.conf = conf
+        self.confs = conf.confs
+        self.local = local
+        if type is None:
+            type = conf.confs.get_data_type(data, 0, conf.default_type())
+        self.type = type
+
+pass

buildz-0.4.1/buildz/ioc/ioc/conf.py

@@ -0,0 +1,118 @@
+#coding=utf-8
+from buildz import xf, pyz
+from buildz.xf import g as xg
+import json
+from .base import Base, EncapeData
+class Conf(Base):
+    def get_key(self, obj, key = 'id', index=0):
+        if type(obj)==dict:
+            return obj[key]
+        id = obj[index]
+        if type(id) in [list, tuple]:
+            return id[0]
+        return id
+    def map(self, arr, fc_key):
+        return {fc_key(obj): obj for obj in arr}
+    def init(self, conf, confs):
+        """
+            {
+                deals:[{build: fc_path,args: [],maps: {}}]
+                envs: {id: val}
+                id: default null
+                namespace: default null
+                datas: [{id:val, type: val, ...}]
+                locals: [like datas]
+                default_type: default null
+            }
+        """
+        id = xf.g(conf, id=None)
+        if id is None:
+            id = confs.conf_id()
+        self.id = id
+        self.namespace = xf.g(conf, namespace=None)
+        self.conf = conf
+        self.confs = confs
+        self.locals = self.map(xf.g(conf, locals=[]), self.confs.get_data_id)
+        self.datas = self.map(xf.g(conf, datas=[]), self.confs.get_data_id)
+        self.deals = self.map(xf.g(conf, deals = []), self.confs.get_deal_type)
+        self._default_type = xf.g(conf, default_type = None)
+        self.envs = xf.g(conf, envs = {})
+        self.confs.flush_env(self.envs)
+        for _type in list(self.deals.keys()):
+            conf = self.deals[_type]
+            if type(conf) in [list, tuple]:
+                maps = {}
+                maps['type'] = conf[0]
+                maps['build'] = conf[1]
+                arr = conf[2:]
+                if len(arr)>0:
+                    maps['args'] = arr.pop(0)
+                if len(arr)>0:
+                    maps['maps'] = arr.pop(0)
+                conf = maps
+            fc = pyz.load(conf["build"])
+            args = xf.g(conf, args=[])
+            maps = xf.g(conf, maps={})
+            deal = fc(*args, **maps)
+            self.deals[_type] = deal
+            aliases = xf.g(conf, aliases = [])
+            for alias in aliases:
+                self.deals[alias] = deal
+    def get_env(self, id, search_confs = True):
+        if self.confs.global_env and search_confs:
+            return self.confs.get_env(id, self.id)
+        ids = self.confs.env_ids(id)
+        envs = self.envs
+        find = None
+        for id in ids:
+            if type(envs)!=dict:
+                envs = None
+                break
+            if id not in envs:
+                envs = None
+                break
+            envs = envs[id]
+        if envs is not None:
+            return envs
+        if not search_confs:
+            return None
+        return self.confs.get_env(id, self.id)
+    def get_deal(self, type, search_confs = True):
+        if self.confs.global_deal and search_confs:
+            return self.confs.get_deal(type, self.id)
+        if type in self.deals:
+            return self.deals[type]
+        if not search_confs:
+            return None
+        return self.confs.get_deal(type, self.id)
+    def get_data(self, id, local = True, search_confs = True):
+        if id in self.datas:
+            obj = self.datas[id]
+            return EncapeData(obj, self, local = False)
+        if not local:
+            return None
+        if id in self.locals:
+            obj = self.locals[id]
+            return EncapeData(obj, self, local = True)
+        if not search_confs:
+            return None
+        return self.confs.get_data(id, self.id)
+    def get(self, *args, **maps):
+        return self.get_obj(*args, **maps)
+    def default_type(self):
+        if self._default_type is None:
+            return self.confs.default_type
+        return self._default_type
+    def get_obj(self, id):
+        """
+            根据data id获取data对象，处理逻辑：根据data id查配置，根据配置的type查deal，返回deal处理过的配置
+        """
+        conf = self.get_data(id)
+        if conf is None:
+            return None
+        deal = self.get_deal(conf.type)
+        if deal is None:
+            return None
+        return deal(conf)
+
+pass

buildz-0.4.1/buildz/ioc/ioc/confs.py

@@ -0,0 +1,286 @@
+#coding=utf-8
+from buildz import xf, pyz
+from buildz.xf import g as xg
+import json
+from .base import Base, EncapeData
+from .conf import Conf
+import os
+class ConfsNode(Base):
+    def init(self):
+        self.confs = []
+        self.ids = {}
+
+pass
+
+
+class Confs(Base):
+    """
+
+    """
+    def flush_env(self, envs):
+        """
+            a.b.c:d -> a:{b:{c:d}}
+        """
+        for key in list(envs.keys()):
+            val = envs[key]
+            if type(val)==dict:
+                self.flush_env(val)
+            ids = self.env_ids(key)
+            if len(ids)>1:
+                del envs[key]
+            pids = ids[:-1]
+            id = ids[-1]
+            tmp = envs
+            for pid in pids:
+                if pid not in tmp:
+                    tmp[pid] = {}
+                tmp = tmp[pid]
+            if id not in tmp:
+                tmp[id] = val
+                continue
+            tval = tmp[id]
+            if type(tval) == dict and type(val)==dict:
+                self.update_maps(tval, val)
+            else:
+                tmp[id] = val
+    def env_ids(self, id):
+        return id.split(self.env_spt)
+    def env_id(self, ids):
+        return self.env_spt.join(ids)
+    def get_env(self, id, sid=None):
+        if sid is not None and not self.global_env:
+            val = self.confs[sid].get_env(id, False)
+            if val is not None:
+                return val
+        sysdt = os.getenv(id)
+        if sysdt is not None:
+            return sysdt
+        ids = self.env_ids(id)
+        envs = self.envs
+        for id in ids:
+            if type(envs)!=dict:
+                envs = None
+                break
+            if id not in envs:
+                envs = None
+                break 
+            envs = envs[id]
+        return envs
+    def set_env(self, id, val):
+        obj = {id:val}
+        self.flush_env(obj)
+        self.update_maps(self.envs, obj)
+    def set_deal(self, type, fc):
+        self.deals[type] = fc
+    def init_fp(self, fp):
+        conf = self.loads(xf.fread(fp))
+        self.init(conf, self.loads)
+    def by_json(self):
+        self.by('json')
+    def by_xf(self):
+        self.by('xf')
+    def by(self, type = 'xf'):
+        if type == 'xf':
+            self.loads = xf.loads
+        elif type == 'json':
+            self.loads = json.loads
+        else:
+            raise Exception("only 'xf' and 'json' impl now")
+    def get_key(self, obj, key = 'id', index=0):
+        if type(obj)==dict:
+            return obj[key]
+        id = obj[index]
+        if type(id) in [list, tuple]:
+            return id[0]
+        return id
+    def init(self, conf={}, loads = None):
+        """
+        {
+            // 环境变量的分隔符
+            // default = '.'
+            env_spt: .
+            // 数据id的分隔符
+            // default = "."
+            spt: .
+            // 数据的默认类型(处理方式)
+            // default = 'default'
+            default_type: default
+            // 全局查id的时候是从最上层开始找还是从最下层开始找（每一层都可能有配置文件）
+            // default = false
+            deep_first: false
+            // true=环境变量env都是全局的（全局查找），否则优先每个配置文件里查环境变量，查不到才查全局
+            // default = true
+            global_env: true
+            // true=类型处理函数deal都是全局的（全局查找），否则优先每个配置文件里查处理函数，查不到才查全局
+            // default = true 
+            global_deal: true
+            // 数据的id字段名
+            // default = 'id'
+            data_key_id: id
+            // 数据的type字段名
+            // default = 'type'
+            data_key_type: type
+            // 数据配置参数是数组的时候，数据id的位置
+            // default=[0,0]
+            data_index_id: [0,0]
+            // 数据配置参数是数组的时候，数据type的位置
+            // default=[0,1]
+            data_index_type: [0,1]
+            // 处理deal的type字段名
+            // default = 'type'
+            deal_key_type: type
+            // deal配置参数是数组的时候，数据type的位置
+            // default=0
+            deal_index_type: 0
+        }
+        """
+        if loads is None:
+            loads = xf.loads
+        self.loads = loads
+        if type(conf) in [bytes, str]:
+            conf = self.loads(conf)
+        self.spt = xf.g(conf, spt = ".")
+        self.env_spt = xf.g(conf, env_spt = ".")
+        self.default_type = xf.g(conf, default_type='default')
+        self.deep_first = xf.g(conf, deep_first=False)
+        self.global_env = xf.g(conf, global_env = True)
+        self.global_deal = xf.g(conf, global_deal = True)
+        self.data_key_id = xf.g(conf, data_key_id = 'id')
+        self.data_key_type = xf.g(conf, data_key_type = 'type')
+        self.data_index_id = xf.g(conf, data_index_id = [0,0])
+        self.data_index_type = xf.g(conf, data_index_type = [0,1])
+        self.deal_key_type = xf.g(conf, deal_key_type = 'type')
+        self.deal_index_type = xf.g(conf, deal_index_type = 0)
+        self._conf_id = 0
+        self.conf = conf
+        self.node = ConfsNode()
+        self.confs = {}
+        self.deals = {}
+        self.envs = {}
+    def get_deal_type(self, obj):
+        if type(obj)==dict:
+            return obj[self.deal_key_type]
+        return obj[self.deal_index_type]
+    def get_data_id(self, obj):
+        if type(obj)==dict:
+            return obj[self.data_key_id]
+        obj = obj[self.data_index_id[0]]
+        if type(obj) in [list, tuple]:
+            obj = obj[self.data_index_id[1]]
+        return obj
+    def get_data_type(self, obj, type_first = 1, default = None):
+        if type(obj)==dict:
+            if self.data_key_type not in obj:
+                return default
+            return obj[self.data_key_type]
+        obj = obj[self.data_index_type[0]]
+        if type(obj) in [list, tuple]:
+            return obj[self.data_index_type[1]]
+        if type_first:
+            return obj
+        return default
+    def conf_id(self):
+        """
+            给每个配置文件加一个id，外部不调用
+        """
+        id = self._conf_id
+        self._conf_id+=1
+        return id
+    def ids(self, id):
+        if id is None:
+            return []
+        """
+            data的id转id列表，外部不调用
+            例: id = 'a.b.c', spt = ".", ids = ['a','b','c']
+        """
+        return id.split(self.spt)
+    def id(self, ids):
+        """
+            data的id列表转id，外部不调用
+            例: ids = ['a','b','c'], spt = ".", id = 'a.b.c', 
+        """
+        return self.spt.join(ids)
+    def add_fp(self, fp):
+        conf = self.loads(xf.fread(fp))
+        return self.add(conf)
+    def add(self, conf):
+        """
+            {
+                deals:[{build: fc_path,args: [],maps: {}}]
+                envs: {id: val}
+                id: default null
+                namespace: default null
+                datas: [{id:val, type: val, ...}]
+                locals: [like datas]
+            }
+        """
+        if type(conf) in [bytes, str]:
+            conf = self.loads(conf)
+        obj = Conf(conf, self)
+        id = xf.g(conf, namespace=None)
+        ids = self.ids(id)
+        node = self.node
+        for id in ids:
+            if id not in node.ids:
+                node.ids[id] = ConfsNode()
+            node = node.ids[id]
+        node.confs.append(obj)
+        self.confs[obj.id] = obj
+        for k in obj.deals:
+            self.deals[k] = obj.deals[k]
+        self.update_maps(self.envs, obj.envs)
+    def get(self, *args, **maps):
+        return self.get_obj(*args, **maps)
+    def get_obj(self, id, sid = None):
+        """
+            根据data id获取data对象，处理逻辑：根据data id查配置，根据配置的type查deal，返回deal处理过的配置
+        """
+        conf = self.get_data(id, sid)
+        if conf is None:
+            return None
+        deal = self.get_deal(conf.type, sid)
+        if deal is None:
+            return None
+        #print(f"get_obj: {id}({sid}), conf: {conf}, deal: {deal}, type: {conf.type}")
+        return deal(conf)
+    def get_deal(self, type, sid=None):
+        """
+            根据type类型查处理函数deal，sid（配置文件id）不为空并且global_deal=False则先查局部
+        """
+        if sid is not None and not self.global_deal:
+            deal = self.confs[sid].get_deal(type, False)
+            if deal is not None:
+                return deal
+        if type in self.deals:
+            return self.deals[type]
+        return None
+    def get_confs(self, ids):
+        """
+            根据ids查所有对应的配置文件列表
+        """
+        node = self.node
+        confs = []
+        for i in range(len(ids)):
+            id = ids[i]
+            confs.append([node.confs,i])
+            if id not in node.ids:
+                break
+            node = node.ids[id]
+        return confs
+    def get_data(self, id, sid=None):
+        """
+            根据id查对应的data配置
+        """
+        ids = self.ids(id)
+        arr = self.get_confs(ids)
+        if self.deep_first:
+            arr.reverse()
+        for confs,i in arr:
+            id = self.id(ids[i:])
+            for conf in confs:
+                conf = conf.get_data(id, sid==conf.id, False)
+                if conf is not None:
+                    return conf
+        return None
+
+pass