buildz 0.6.53__tar.gz → 0.6.55__tar.gz

{buildz-0.6.53/buildz.egg-info → buildz-0.6.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.6.53
+Version: 0.6.55
 Summary: 配置读写（基于json格式进行简化）、ioc、以及其他工具代码。a json-base file format's read and write code by python, and codes to read and product object from configure file in such format(ioc), and other tool codes
 Home-page: https://github.com/buildCodeZ/buildz
 Author: Zzz

buildz-0.6.55/buildz/argz/argz.py

@@ -0,0 +1,232 @@
+from .. import Base, xf, dz
+class ArgExp(Exception):
+    def __repr__(self):
+        return self.__str__()
+    def __str__(self):
+        return f"stype: {self.stype}, trs: {self.trs}, des: {self.des}"
+    def __init__(self, stype, trs, des=None, prev = None):
+        super().__init__()
+        self.prev = prev
+        self.stype = stype
+        self.trs = trs
+        self.des = des
+
+pass
+class ArgType:
+    list = 'list'
+    dict='dict'
+    @staticmethod
+    def stand(s):
+        if ArgType.islist(s):
+            return ArgType.list
+        return ArgType.dict
+    @staticmethod
+    def islist(s):
+        return s in ('list','l','lst','args')
+    @staticmethod
+    def isdict(s):
+        return s in ('dict', 'd', 'dct', 'maps')
+
+pass
+class Params(Base):
+    def init(self, args=[], maps={}):
+        self.args = args
+        self.maps = maps
+class Args(Base):
+    '''
+        参数映射基础类
+    '''
+    Type=ArgType
+    def call(self, params):
+        return params
+    def deal(self, args, maps):
+        params = self.call(Params(args,maps))
+        return params.args, params.maps
+    def deal_exp(self, exp):
+        return exp
+
+pass
+class ArrArgs(Args):
+    '''
+        参数映射类的队列，顺序处理
+    '''
+    def str(self):
+        return f"ArrArgs(args={self.args})"
+    def init(self, args = None):
+        if args is None:
+            args = []
+        self.args = args
+    def add(self, item):
+        self.args.append(item)
+        return self
+    def call(self, params):
+        args, maps = params.args, params.maps
+        i=0
+        try:
+            for i in range(len(self.args)):
+                item = self.args[i]
+                params = item(params)
+        except ArgExp as exp:
+            exp = self.deal_exp(exp, i-1)
+            raise exp
+        #params.args, params.maps = args, maps
+        return params
+    def deal_exp(self, exp, base=None):
+        if base is None:
+            base = len(self.args)-1
+        for i in range(base, -1, -1):
+            exp = self.args[i].deal_exp(exp)
+        return exp
+class RangeListArgs(Args):
+    '''
+        范围映射
+    '''
+    def str(self):
+        return f"RangeArgs(base={self.base}, last={self.last}, min={self.min})"
+    def init(self, base = 0, last = None, min=0):
+        self.base = base
+        self.last = last
+        self.min = min
+    def deal_exp(self, exp):
+        trs = set()
+        for key, vtype in exp.trs:
+            if ArgType.islist(vtype):
+                trs.add((key+self.base, vtype))
+            else:
+                trs.add((key, vtype))
+        return ArgExp(exp.stype, trs, exp.des, exp)
+    def call(self, params):
+        args, maps = params.args, params.maps
+        if self.last is None:
+            args = args[self.base:]
+        else:
+            args = args[self.base:self.last]
+        if len(args)<self.min:
+            raise ArgExp("need", set([(self.base, 'list')]))
+        return Params(args, maps)
+        params.args, params.maps = args, maps
+        return params
+
+
+class ArgItem(Base):
+    '''
+        单个字段映射处理
+    '''
+    # vtype = 'dict' | 'list'
+    def init(self, key, vtype=ArgType.dict, need = False, default = False, default_value = None, des = None,remove=True):
+        self.vtype = vtype
+        self.key = key
+        self.need = need
+        self.default = default
+        self.default_value = default_value
+        self.trs = []
+        self.remove = remove
+        if des is None:
+            des = key
+        self.des = des
+    def add(self, key, vtype=ArgType.dict):
+        self.trs.append((key, vtype))
+        return self
+    def deal_exp(self, exp):
+        trs = set()
+        for key, vtype in exp.trs:
+            if key == self.key and vtype==self.vtype:
+                trs.update(self.trs)
+            else:
+                trs.add((key, vtype))
+        return ArgExp(exp.stype, trs, exp.des, exp)
+    def fetch(self, key, vtype, set_args, args, maps):
+        find = False
+        val=None
+        if ArgType.isdict(vtype):
+            val,find = dz.dget(maps, key)
+            if find:
+                if self.remove:
+                    dz.dremove(maps, key)
+        else:
+            if key in set_args:
+                val = args[key]
+                if self.remove:
+                    set_args.remove(key)
+                find = True
+        return val, find
+    def call(self, set_args, args, maps, rst_args, rst_maps):
+        val = None
+        find = False
+        for key, vtype in self.trs:
+            val, find = self.fetch(key, vtype, set_args, args, maps)
+            if find:
+                break
+        if not find and self.default:
+            find = True
+            val = self.default_value
+        if not find and self.need:
+            raise ArgExp("need", set(self.trs), self.des)
+        if not find:
+            return
+        if ArgType.isdict(self.vtype):
+            xf.dset(rst_maps, self.key, val)
+        else:
+            rst_args[self.key] = val
+
+pass
+class ListFill:
+    '''
+        数组映射后，中间缺失位置如何处理
+        exp=报错
+        null=填充None
+    '''
+    exp='exp'
+    null = 'null'
+    default=exp
+class TrsArgs(Args):
+    def str(self):
+        return f"TrsArgs(args={len(self.args)}, keep={self.keep}, fill = {self.list_fill})"
+    '''
+        数据映射
+    '''
+    def deal_exp(self, exp):
+        for item in self.args:
+            exp = item.deal_exp(exp)
+        return exp
+    def init(self, args=None, keep = False, list_fill = ListFill.default):
+        super().init()
+        if args is None:
+            args = []
+        self.args = args
+        self.keep = keep
+        self.list_fill = list_fill
+    def add(self, item):
+        self.args.append(item)
+        return self
+    def call(self, params):
+        args, maps = params.args, params.maps
+        rst_args, rst_maps = {}, {}
+        set_args = set(range(len(args)))
+        for item in self.args:
+            item(set_args, args, maps, rst_args, rst_maps)
+        if self.keep and len(set_args)>0:
+            for i in set_args:
+                if i not in rst_args:
+                    rst_args[i] = args[i]
+        l_args = 0
+        if len(rst_args)>0:
+            l_args= max(rst_args.keys())+1
+        out_args = []
+        for i in range(l_args):
+            if i in rst_args:
+                out_args.append(rst_args[i])
+            else:
+                if self.list_fill == ListFill.null:
+                    out_args.append(None)
+                else:
+                    raise ArgExp("need", set([(i, ArgType.list)]))
+        if self.keep:
+            for k in maps:
+                if k not in rst_maps:
+                    rst_maps[k] = maps[k]
+        return Params(out_args, rst_maps)
+        params.args, params.maps = out_args, rst_maps
+        return params
+
+pass

buildz-0.6.55/buildz/argz/callz.py

@@ -0,0 +1,47 @@
+from buildz import Base, xf, dz
+from . import argz
+from . import evalx
+class Fc(Base):
+    def str(self):
+        return str(self.fc)
+    def init(self, fc=None):
+        self.fc = fc
+    def call(self, params):
+        return self.fc(*params.args, **params.maps), 1
+    @staticmethod
+    def make(fc):
+        if isinstance(fc, Fc):
+            return fc
+        return Fc(fc)
+class RetFc(Fc):
+    def call(self, params):
+        return (params.args, params.maps), 1
+class Call(Fc):
+    def str(self):
+        return str(self.fcs)
+    def init(self, fc, args=None, eval=None):
+        if not dz.islist(fc):
+            fc = [fc]
+        fc = [self.make(k) for k in fc]
+        self.fcs = fc
+        self.args = args
+        self.eval = eval
+    def call(self, params):
+        if self.eval is not None:
+            if not self.eval(params):
+                return None,0
+        if self.args is not None:
+            params = self.args(params)
+        try:
+            rst = None,0
+            for fc in self.fcs:
+                val,mark_call = fc(params)
+                if mark_call:
+                    rst = val, mark_call
+            return rst
+        except argz.ArgExp as exp:
+            if self.args is not None:
+                exp = self.args.deal_exp(exp)
+            raise exp
+    def add(self, fc):
+        self.fcs.append(self.make(fc))

buildz-0.6.55/buildz/argz/conf_argz.py

@@ -0,0 +1,118 @@
+from ..iocz.conf import conf
+from .. import Base, xf, dz,pyz
+from .argz import *
+"""
+key:{
+    src: [a,b,c]
+    des: asdf
+    need:1
+    default: True
+    default_value: 123
+    remove: 1
+}
+key: [
+    src, 
+    [default, default_value]
+    [des, need, remove]
+]
+"""
+class ArgItemConf(conf.Conf):
+    def init(self):
+        super().init()
+        self.index(0, 'src')
+        self.key('src')
+        df = conf.Conf()
+        df.index(0, 'default')
+        df.index(1, 'default_value')
+        self.index(1,deal= df, dict_out=1)
+        self.key('default', deal=df, dict_out=1)
+        des = conf.Conf()
+        des.index(0, 'des')
+        des.index(1,'need')
+        des.index(2, 'remove')
+        self.index(2, deal=des, dict_out=1)
+
+pass
+class ArgSrcConf(conf.Conf):
+    def init(self):
+        super().init()
+        self.index(0, 'key', need=1)
+        self.key('key', 'val,value,data'.split(','), need=1)
+        self.index(1, 'type')
+        self.key('type', 'vtype'.split(","))
+    def call(self, data, unit=None):
+        data, upd = super().call(data, unit)
+        val = data['key']
+        if 'type' not in data:
+            if type(val)==int:
+                vtype = ArgType.list
+            else:
+                vtype = ArgType.dict
+        else:
+            vtype = data['type']
+        data['type'] = ArgType.stand(vtype)
+        return data, upd
+
+class TrsArgsBuilder(Base):
+    def init(self):
+        self.conf = ArgItemConf()
+        self.src_conf = ArgSrcConf()
+    def visits(self, datas, vtype,obj):
+        for key, item in dz.dict2iter(datas):
+            item,_ = self.conf(item)
+            it = ArgItem(key, vtype, *dz.g(item, need=0, default=0, default_value=None,des=None, remove=True))
+            srcs = dz.g(item, src=[])
+            if not dz.islist(srcs):
+                srcs = [srcs]
+            for src in srcs:
+                src, _ = self.src_conf(src)
+                key, vtype = src['key'], src['type']
+                it.add(key, vtype)
+            obj.add(it)
+    def call(self, conf):
+        lists = xf.g(conf, list={})
+        dicts = xf.g(conf, dict={})
+        if len(lists)+len(dicts)==0:
+            return None
+        keep,list_fill = xf.g(conf, keep=0, fill='exp')
+        obj = TrsArgs([], keep, list_fill)
+        self.visits(lists, ArgType.list, obj)
+        self.visits(dicts, ArgType.dict, obj)
+        return obj
+
+class FullArgsBuilder(Base):
+    def init(self):
+        self.trs_build = TrsArgsBuilder()
+        cf = conf.Conf()
+        rcf = conf.Conf()
+        rcf.index(0, 'base')
+        rcf.index(1, 'last')
+        rcf.index(2, 'min')
+        cf.index(0, 'range', deal=rcf)
+        cf.key('range', 'ranges'.split(","), deal=rcf)
+        cf.index(1, 'list')
+        cf.index(2, 'dict')
+        cf.key('list', 'args,lists'.split(","))
+        cf.key("dict", 'maps,dicts'.split(","))
+        _cf = conf.Conf()
+        _cf.index(0, 'keep')
+        _cf.index(1, 'fill')
+        _cf.key('fill', 'fill_type'.split(','))
+        cf.index(3, deal=_cf, dict_out=1)
+        self.conf = cf
+    def call(self, conf):
+        arr_args = ArrArgs()
+        conf, upd = self.conf(conf)
+        #print(f"BUILD conf: {conf}")
+        ranges = dz.g(conf, range=None)
+        if ranges is not None:
+            base = ranges['base']
+            if base is not None:
+                last, min = dz.g(ranges, last=None,min=0)
+                min = pyz.nnull(min, 0)
+                range_args = RangeListArgs(base, last, min)
+                arr_args.add(range_args)
+        trs_args = self.trs_build(conf)
+        if trs_args is not None:
+            arr_args.add(trs_args)
+        return arr_args

buildz-0.6.55/buildz/argz/conf_callz.py

@@ -0,0 +1,136 @@
+from ..iocz.conf import conf
+from .. import Base, xf, dz,pyz
+from .callz import *
+from ..iocz.ioc_deal.base import BaseEncape,BaseDeal
+from ..iocz.conf.up import BaseConf
+from .conf_argz import *
+from .evalx import *
+from .. import iocz
+from . import argz
+class EnvFc(Fc):
+    def init(self, unit):
+        super().init()
+        self.unit = unit
+    def call(self, params):
+        self.unit.update_env(params.maps)
+        return True,1
+class ArgsCallEncape(BaseEncape):
+    def init(self, fcs, args, eval, unit):
+        super().init()
+        self.fcs = fcs
+        self.args = args
+        self.eval = eval
+        self.call_fc = None
+        self.unit = unit
+    def ref(self, key, unit):
+        key = self.obj(key)
+        if type(key)==str:
+            rst, find = unit.get(key)
+            assert find, f"fc not found: '{key}'"
+            key=rst
+        return key
+    def call(self, params=None):
+        if self.call_fc is None:
+            fcs = [self.ref(fc, self.unit) for fc in self.fcs]
+            self.call_fc = Call(fcs, self.args, self.eval)
+        return self.call_fc
+class ArgsCallDeal(BaseDeal):
+    def init(self, fc=True, update_env = False):
+        super().init()
+        _conf = BaseConf()
+        index=1
+        self.fc = fc
+        self.update_env = update_env
+        if fc:
+            _conf.ikey(1, 'fc', 'fcs,calls,call'.split(','))
+            _conf.ikey(2, 'eval', "judges,judge,evals".split(","))
+            _conf.ikey(3, 'conf')
+        else:
+            _conf.ikey(2, 'eval', "judges,judge,evals".split(","))
+            _conf.ikey(1, 'conf')
+        self.update=_conf
+        self.args_builder = FullArgsBuilder()
+    def deal(self, conf, unit):
+        conf_eval = dz.g(conf, eval=None)
+        conf_args = dz.g(conf, conf=None)
+        _eval = None
+        if conf_eval is not None:
+            _eval = evalBuilder(conf_eval)
+        _args = None
+        if conf_args is not None:
+            _args = self.args_builder(conf_args)
+        if self.fc:
+            fcs = dz.g(conf, fc=[])
+            if type(fcs)==str:
+                fcs = [fcs]
+            fcs = [self.get_encape(fc, unit) for fc in fcs]
+        else:
+            if self.update_env:
+                fcs = [EnvFc(unit)]
+            else:
+                fcs = [RetFc()]
+        # if self.update_env and not self.fc:
+        #     return UpdateEnvEncape(_args, _eval, unit)
+        return ArgsCallEncape(fcs, _args, _eval, unit)
+class RetArgsDeal(ArgsCallDeal):
+    def init(self):
+        super().init(False)
+class UpdateEnvDeal(ArgsCallDeal):
+    def init(self):
+        super().init(False,True)
+confs = xf.loads(r"""
+# confs.pri: {
+#     deal_args: {
+#         type=deal
+#         src=buildz.argzx.conf_callz.ArgsCallDeal
+#         call=1
+#         deals=[call,fc]
+#     }
+# }
+confs.pri: [
+    (
+        (deal, deal_ret)
+        buildz.argz.conf_callz.RetArgsDeal
+        1,
+        [argz_ret,ret]
+    )
+    (
+        (deal, deal_argz_env)
+        buildz.argz.conf_callz.UpdateEnvDeal
+        1,
+        [argz_env,argz_envs]
+    )
+    (
+        (deal, deal_args)
+        buildz.argz.conf_callz.ArgsCallDeal
+        1,
+        [argz,argz_call,argz_fc]
+    )
+]
+builds: [deal_args, deal_ret, deal_argz_env]
+""")
+class ConfBuilder(Base):
+    def init(self, conf=None):
+        mg = iocz.build(conf)
+        mg.add_conf(confs)
+        self.mg = mg
+        for key in 'push_var,push_vars,pop_var,pop_vars,set_var,set_vars,get_var,unset_var,unset_vars'.split(","):
+            setattr(self, key, getattr(mg,key))
+    def adds(self, conf):
+        if type(conf)==str:
+            conf = xf.loads(conf)
+        conf = {'confs': conf}
+        self.mg.add_conf(conf)
+    def add(self, conf):
+        if type(conf)==str:
+            conf = xf.loads(conf)
+        conf = {'confs': [conf]}
+        self.mg.add_conf(conf)
+    def call(self, key, args, maps):
+        params = argz.Params(args, maps)
+        #p = iocz.Params(params=params)
+        fc, find = self.mg.get(key)
+        #rst, find = self.mg.get(key, params=p)
+        assert find, f"key not found: '{key}'"
+        return fc(params)[0]
+        return rst[0]

buildz-0.6.55/buildz/argz/evalx.py

@@ -0,0 +1,21 @@
+#
+from .. import evalz,xf,Base
+
+class VarEval(evalz.Eval):
+    def init(self, key, stype = 'list'):
+        self.key = key
+        self.stype = stype
+    def call(self, obj):
+        args, maps = obj.args, obj.maps
+        if self.stype=='list':
+            return args[self.key]
+        return maps[self.key]
+class VarBuild(evalz.Build):
+    def init(self, stype="list"):
+        super().init()
+        self.stype = stype
+    def call(self, data):
+        return VarEval(data['data'][0], self.stype)
+lb = VarBuild('list')
+db = VarBuild('dict')
+evalBuilder = evalz.EvalBuilder.Make().set(["l","list","args"], lb).set(['d','dict','maps'], db)

buildz-0.6.55/buildz/argz/init.py

@@ -0,0 +1,7 @@
+#
+
+from .conf_callz import *
+def build(conf=None):
+    return ConfBuilder(conf)
+
+pass

buildz-0.6.55/buildz/argz/test.py

@@ -0,0 +1,29 @@
+#
+
+from buildz.argz import conf_argz as argz
+from buildz.tls import *
+conf = xf.loads(r"""
+#range=(0,12,3)
+range=(1,12,1)
+args: {
+    0:[0,0]
+}
+maps: {
+    a={
+        default: test
+    }
+}
+""")
+def test():
+    args = [0,1,2]
+    maps = {'a':'b','c':'d'}
+    bd = argz.FullArgsBuilder()
+    obj = bd(conf)
+    args, maps = obj.deal(args, maps)
+    print(f"obj: {obj}")
+    print(f"args: {args}, maps: {maps}")
+    pass
+
+pass
+
+pyz.lc(locals(),test)

buildz-0.6.55/buildz/argz/test_call.py

@@ -0,0 +1,63 @@
+#
+
+#from buildz.argz import conf_argz as argz
+from buildz.argz import conf_callz as callz
+from buildz.tls import *
+conf = r"""
+(
+    (argz, main)
+    (search, test_ret,test_var,test_env)
+)
+{
+    type: argz
+    id: search
+    call: search_fc
+    judge: eq(args[0], search)
+    conf={
+        range: 1
+        dict: {
+            dp: ((0, dp), false, (null,1))
+            pt_fp: ((1, pt_fp), (true,null))
+            pt: ((2, pt), (true,null))
+        }
+    }
+}
+[
+    (argz_ret, test_ret)
+    [1]
+    eq(args[0], test)
+]
+[
+    (argz_env, test_env)
+    [1]
+    eq(args[0], env)
+]
+[
+    (argz, test_var)
+    test_fc
+    eq(args(0), var)
+]
+[
+    (cvar, search_fc)
+    buildz.fz.search
+]
+"""
+def test_fc(*a, **b):
+    print(f"test_fc({a}, {b})")
+    return a,b
+def test():
+    args = ['env','.']
+    maps = {
+        'pt_fp': r".*\.py$"
+    }
+    bd = argz.build()
+    bd.adds(conf)
+    bd.push_var("test_fc",test_fc)
+    rst = bd("main", args, maps)
+    print(f"rst: {rst}")
+    print(bd.mg.envs)
+    pass
+
+pass
+
+pyz.lc(locals(),test)

buildz-0.6.55/buildz/argz_bk/tests/conf.js

@@ -0,0 +1,34 @@
+{
+    id: main
+    type: calls
+    range: 1
+    calls: [
+        search
+    ]
+}
+{
+    id: search
+    type: call
+    src: search
+    judge: ['=', args[0], search]
+    args: [1, [[0,()], [1, ()], {}]]
+    args: {
+        range: 1
+        keep: 1
+        list: {
+            0: {
+                des: path
+                need: 1
+                src: 0
+            }
+        }
+        dict: {
+            filepath: {
+                srcs: [f, fp, filepath]
+            }
+            content: {
+                srcs: [c, ct, content]
+            }
+        }
+    }
+}