buildz 0.6.45__tar.gz → 0.6.47__tar.gz

buildz-0.6.47/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+recursive-include buildz *
+recursive-include notes *

{buildz-0.6.45/buildz.egg-info → buildz-0.6.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.6.45
+Version: 0.6.47
 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.45 → buildz-0.6.47}/buildz/argz/argz.py

@@ -103,12 +103,18 @@ class ArgItem(Base):
         find = False
         for key, vtype in self.trs:
             if vtype =="dict":
-                if key in maps:
-                    val = maps[key]
+                if xf.dhas(maps, key):
+                    val = xf.dget(maps, key)
                     if self.remove:
-                        del maps[key]
-                    find = True
+                        xf.dremove(maps, key)
+                    find=True
                     break
+                #if key in maps:
+                #    val = maps[key]
+                #    if self.remove:
+                #        del maps[key]
+                #    find = True
+                #    break
             else:
                 if key in set_args:
                     val = args[key]
@@ -123,7 +129,8 @@ class ArgItem(Base):
         if not find and self.need:
             raise ArgExp("need", set(self.trs), self.des)
         if self.vtype == 'dict':
-            rst_maps[self.key] = val
+            xf.dset(rst_maps, self.key, val)
+            #rst_maps[self.key] = val
         else:
             rst_args[self.key] = val
 
@@ -135,9 +142,11 @@ class ArgItemBuild(build.Build):
         value = xf.g(conf, value=None)
         des = xf.g(conf, des=None)
         remove = xf.g(conf, remove=True)
-        src = conf['src']
-        if type(src) not in (list, tuple):
-            src = [src]
+        src = xf.g(conf, src=None)
+        srcs = xf.g(conf, srcs = [])
+        if src is not None:
+            srcs.append(src)
+        src = srcs
         item = ArgItem(key, vtype, need, default, value, des, remove)
         for s in src:
             if type(s) not in (list, tuple):

{buildz-0.6.45 → buildz-0.6.47}/buildz/argz/build.py

@@ -1,5 +1,5 @@
 #
-from buildz import Base, xf
+from buildz import Base, xf,pyz
 class Build(Base):
     def init(self, *binds):
         self.builder = None
@@ -11,10 +11,11 @@ class Build(Base):
     def call(self, conf):
         assert 0, 'not impl'
 class Builder(Base):
-    def init(self, fc = None, key_id = "id"):
+    def init(self, fc = None, key_id = "id", default_key = "main"):
         self.vars = {}
         self.confs = {}
         self.key_id = key_id
+        self.df_key = default_key
         self.set_fc(fc)
     def set_fc(self, fc):
         fc.bind(self)
@@ -34,6 +35,12 @@ class Builder(Base):
             conf = self.confs[key]
         return self.fc(conf)
     def conf(self, data):
+        if type(data) == dict:
+            tp = xf.g(data, type=None)
+            if tp is not None and type(tp) not in (list, tuple, dict):
+                if self.key_id not in data:
+                    data[self.key_id] = self.df_key
+                data = [data]
         if type(data) in (list, tuple):
             rst = {}
             for it in data:
@@ -44,5 +51,6 @@ class Builder(Base):
             data = rst
         self.confs = data
         return self
-    def call(self, data, key="main"):
+    def call(self, data, key=None):
+        key = pyz.nnull(key, self.df_key)
         return self.conf(data).get_conf(key)

{buildz-0.6.45 → buildz-0.6.47}/buildz/argz/callz.py

@@ -14,6 +14,9 @@ class Fc(Base):
         if isinstance(fc, Fc):
             return fc
         return Fc(fc)
+class RetFc(Fc):
+    def call(self, args, maps):
+        return args, maps
 class ArgsCall(Fc):
     def init(self, fc, args=None, name = None):
         fc=self.make(fc)
@@ -88,23 +91,34 @@ class FcBuild(build.Build):
         src = xf.g(conf, src = None)
         fc = self.builder.get_var(src)
         return Fc(fc)
+class RetBuild(build.Build):
+    def call(self, conf):
+        ctype = xf.g(conf, type=None)
+        if ctype != "ret":
+            return None
+        return RetFc()
 class CallBuild(build.Build):
     def init(self):
         self.args = argz.ArrArgsBuild()
         self.eval = evalx.EvalBuild()
         self.fc = FcBuild()
         self.calls = CallsBuild()
+        self.ret = RetBuild()
         super().init(self.args, self.eval, self.fc, self.calls)
     def call(self, conf):
         args = self.args(conf)
         judges = self.eval(conf)
         fc = self.fc(conf)
         calls = self.calls(conf)
+        ret = self.ret(conf)
         bfc = fc is None
         bcls = calls is None
-        assert (bfc+bcls)==1
+        bret = ret is None
+        assert (bfc+bcls+bret)==2
         if fc is None:
             fc = calls
+        if fc is None:
+            fc = ret
         if args is not None:
             fc = ArgsCall(fc, args)
         if judges is not None:

{buildz-0.6.45 → buildz-0.6.47}/buildz/argz/tests/conf.js

@@ -22,10 +22,10 @@
     }
     maps: {
         filepath: {
-            src: [f, fp, filepath]
+            srcs: [f, fp, filepath]
         }
         content: {
-            src: [c, ct, content]
+            srcs: [c, ct, content]
         }
     }
-}
+}

buildz-0.6.47/buildz/argz/testx.py

@@ -0,0 +1,42 @@
+from buildz import argz,xf,Base,evalz,pathz
+import sys,os
+
+path = pathz.Path()
+path.set("res", path(path.dir(__file__), "tests"))
+conf = xf.loadf(path.res("conf.js"))
+conf=xf.loads(r"""
+type=ret
+maps={
+    spt: {
+        src: [(env, spt), d]
+        default: 1
+        value: '.'
+    }
+    eglobal: {
+        src: [(env, global), d]
+        default:1
+        value: true
+    }
+}
+""")
+
+mg = argz.CallBuilder()
+fc = mg(conf)
+
+data = xf.loads(r"""
+args=[]
+maps={
+    env: {
+        spt: x
+    }
+}
+""")
+args = xf.g(data, args=[])
+maps = xf.g(data, maps={})
+
+rst = fc(args, maps)
+print(f"rst: {rst}")
+'''
+python -m buildz.argz.testx
+python -m buildz.argz.test search /d/rootz f=asf c=test
+'''

{buildz-0.6.45 → buildz-0.6.47}/buildz/base.py

@@ -1,5 +1,33 @@
 #coding=utf-8
 from . import pyz
+def fcBase(cls, lst=0, keys = tuple()):
+    class _Base(cls):
+        def str(self):
+            return str(self.__class__)
+        def repr(self):
+            return self.str()
+        def __str__(self):
+            return self.str()
+        def __repr__(self):
+            return self.repr()
+        def __call__(self, *a, **b):
+            return self.call(*a, **b)
+        def call(self, *a, **b):
+            return None
+        def init(self, *a, **b):
+            pass
+        def __init__(self, *a, **b):
+            sa = a[:lst]
+            a = a[lst:]
+            sb = {}
+            for k in keys:
+                if k in b:
+                    sb[k] = b[k]
+                    del b[k]
+            super().__init__(*sa, **sb)
+            self.init(*a, **b)
+    return _Base
+
 class Base:
     def str(self):
         return str(self.__class__)

buildz-0.6.47/buildz/dz/__init__.py

@@ -0,0 +1,3 @@
+#
+
+from .mapz import *

buildz-0.6.47/buildz/dz/mapz.py

@@ -0,0 +1,323 @@
+from buildz import pyz
+def get(obj, key, default=None, set = False):
+    if type(obj)==list:
+        key = int(key)
+        if len(obj)<=key:
+            return default
+        return obj[key]
+    else:
+        if key not in obj:
+            if set:
+                obj[key] = default
+            return default
+        return obj[key]
+
+pass
+def getf(obj, key, fc):
+    if key not in obj:
+        return fc()
+    return obj[key]
+
+pass
+def gfn(obj, **maps):
+    rst = []
+    for k in maps:
+        if k in obj and obj[k] is not None:
+            v = obj[k]
+        else:
+            v = maps[k]()
+        rst.append(v)
+    if len(rst)==1:
+        rst = rst[0]
+    return rst
+
+pass
+def gf(obj, **maps):
+    rst = []
+    for k in maps:
+        if k in obj:
+            v = obj[k]
+        else:
+            v = maps[k]()
+        rst.append(v)
+    if len(rst)==1:
+        rst = rst[0]
+    return rst
+
+pass
+def get_first(obj, *keys):
+    for k in keys:
+        if k in obj:
+            return obj[k]
+    raise KeyError(keys[0])
+
+pass
+def get_one(obj, keys, default = None):
+    for k in keys:
+        if k in obj:
+            return obj[k]
+    return default
+
+pass
+def g1(obj, **maps):
+    v = None
+    for k in maps:
+        v = maps[k]
+        if k in obj:
+            v = obj[k]
+            return v
+    return v
+
+pass
+def g(obj, **maps):
+    rst = []
+    if obj is None:
+        return maps.values()
+    for k in maps:
+        v = maps[k]
+        if k in obj:
+            v = obj[k]
+        rst.append(v)
+    if len(rst)==1:
+        rst = rst[0]
+    return rst
+
+pass
+def c(obj, **maps):
+    for k in maps:
+        v = maps[k]
+        if k not in obj:
+            return False
+        vo = obj[k]
+        if vo!=v:
+            return False
+    return True
+def gs(obj, **maps):
+    rst = []
+    for k in maps:
+        v = maps[k]
+        if k in obj:
+            v = obj[k]
+        else:
+            obj[k] = v
+        rst.append(v)
+    if len(rst)==1:
+        rst = rst[0]
+    return rst
+
+pass
+def get_set(obj, key, val):
+    if key not in obj:
+        obj[key]=val
+    return obj[key]
+def s(obj, **maps):
+    for k in maps:
+        v = maps[k]
+        obj[k] = v
+
+pass
+def fill_fc(maps, fc):
+    for k in maps:
+        v = maps[k]
+        if type(v) == dict:
+            fill_fc(v, fc)
+            continue
+        maps[k] = fc(v)
+    return maps
+
+pass
+def im2l(maps):
+    if type(maps)!=dict:
+        return maps
+    mx = 0
+    for k in maps:
+        if type(k)==str:
+            k = int(k)
+        if type(k)!=int or k<0:
+            raise Exception(f"args key only can be int and bigger than 0, but {type(k)}:{k} found")
+        mx = max(k+1, mx)
+    arr = [None]*mx
+    for k, v in maps.items():
+        arr[k] = v
+    return arr
+
+pass
+    
+def dset(maps, keys, val):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    for key in keys[:-1]:
+        if type(maps)==dict:
+            if key not in maps:
+                maps[key] = {}
+        else:
+            key = int(key)
+        maps = maps[key]
+    maps[keys[-1]] = val
+
+pass
+def dhas(maps, keys):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    for key in keys:
+        if type(maps)==dict:
+            if key not in maps:
+                return False
+        else:
+            key = int(key)
+            if key>=len(maps):
+                return default
+        maps = maps[key]
+    return True
+
+pass
+
+def dget(maps, keys):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    for key in keys:
+        find = 1
+        if type(maps)==dict:
+            find = key in maps
+        elif type(maps) in (list, tuple):
+            try:
+                key = int(key)
+            except:
+                key = len(maps)
+            find = key<len(maps)
+        else:
+            find = False
+        if not find:
+            return None,0
+        maps = maps[key]
+    return maps,1
+
+pass
+def dremove(maps, keys):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    arr = []
+    for key in keys:
+        if key not in maps:
+            break
+        arr.append([maps, key])
+        maps = maps[key]
+    arr.reverse()
+    first=1
+    for maps,key in arr:
+        if first or len(maps[key])==0:
+            del maps[key]
+        first=0
+    return None
+
+pass
+
+def dhget(maps, keys):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    for key in keys:
+        find = 1
+        if type(maps)==dict:
+            find = key in maps
+        elif type(maps) in (list, tuple):
+            try:
+                key = int(key)
+            except:
+                key = len(maps)
+            find = key<len(maps)
+        else:
+            find = False
+        if not find:
+            return None, find
+        maps = maps[key]
+    return maps, True
+
+pass
+def l2m(arr, **maps):
+    rst = {}
+    i = 0
+    for k in maps:
+        if i<len(arr):
+            val = arr[i]
+        else:
+            val = maps[k]
+        rst[k] = val
+        i+=1
+    return rst
+
+pass
+
+def deep_update(target, src, replace=1):
+    """
+        dict深层更新，src[key]是dict就深入更新，否则:
+            src有而target没有就替换，否则：
+                replace=1就替换
+    """
+    for k in src:
+        val = src[k]
+        if k not in target:
+            target[k] = val
+            continue
+        mval = target[k]
+        if type(mval) == dict and type(val)==dict:
+            deep_update(mval, val, replace)
+        else:
+            if replace:
+                target[k] = val
+
+pass
+update = deep_update
+def deep_fill(src, target, replace=1):
+    return deep_update(target, src, replace)
+
+pass
+def deep_clone(obj):
+    if type(obj)==list:
+        rst = []
+        for it in obj:
+            rst.append(deep_clone(it))
+    elif type(obj)==dict:
+        rst = {}
+        for k,v in obj.items():
+            rst[k] = deep_clone(v)
+    else:
+        rst = obj
+    return rst
+pass
+fill=deep_fill
+
+def maps(**kv):
+    return kv
+
+pass
+
+def flush_maps(maps, fc_key = lambda x:x.split(".") if type(x)==str else [x], visit_list=False):
+    if type(maps)==list:
+        if not visit_list:
+            return maps
+        rst = [flush_maps(it, fc_key, visit_list) for it in maps]
+        return rst
+    if type(maps)!=dict:
+        return maps
+    rst = {}
+    for k,v in maps.items():
+        ks = fc_key(k)
+        v = flush_maps(v, fc_key, visit_list)
+        sets(rst, ks, v)
+    return rst
+
+pass
+def unflush_maps_item(rst, keys, val, fc_key):
+    if type(val)!=dict:
+        key = fc_key(keys)
+        rst[key] = val
+        return
+    for k, v in val.items():
+        unflush_maps_item(rst, keys+[k], v, fc_key)
+def unflush_maps(maps, fc_key = lambda x:".".join([str(k) for k in x]) if type(x) in (list, tuple) else str(x)):
+    if type(maps)!=dict:
+        return maps
+    rst = {}
+    for k,v in maps.items():
+        unflush_maps_item(rst, [k], v, fc_key)
+    return rst

{buildz-0.6.45 → buildz-0.6.47}/buildz/fz/__init__.py

@@ -2,7 +2,7 @@
 #author:
 from .dirz import dirs, FileDeal
 from .lsf import lists, search, searchd,searchs,_search
-from .fio import fread, freads, fwrite, fwrites, read,reads,write,writes, makefdir, dirpath,makedir,removes, cover, fcover, sread, swrite, is_abs
+from .fio import fread, freads, fwrite, fwrites, read,reads,write,writes, makefdir, dirpath,makedir,removes, cover, fcover, sread, swrite, is_abs, xors, fxors, coverx, covers, fcovers
 from .fhs import fhash, fhashs
 
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

{buildz-0.6.45 → buildz-0.6.47}/buildz/fz/fio.py

@@ -56,23 +56,37 @@ pass
 
 dirname = dirpath
 
-def fcover(filepath, wsize = 1024*10):
-	st = os.stat(filepath)
-	size = st.st_size
-	bs = b'a'*wsize
-	with open(filepath, 'wb') as f:
-		for i in range(0, size, wsize):
-			f.write(bs)
+def coverx(sz, chars=None):
+    if chars is None:
+        chars = b"a"
+    if type(chars)==str:
+        chars = chars.encode("utf-8")
+    l = sz//len(chars)
+    cs = chars*l
+    left = sz%len(chars)
+    cs+=chars[:left]
+    return cs
+def fcover(filepath, wsize = 1024*10, chars=None):
+    st = os.stat(filepath)
+    size = st.st_size
+    #print(f"{filepath}:{size}")
+    #bs = b'a'*wsize
+    with open(filepath, 'wb') as f:
+        for i in range(0, size, wsize):
+            sz = min(size-i, wsize)
+            bs = coverx(sz, chars)
+            #print(f"bs: {len(bs)}, sz: {sz}, i:{i}, wsize:{wsize}")
+            f.write(bs)
 
 pass
 cover = fcover
-def removes(fp, cover = False):
+def removes(fp, cover = False,wsize = 1024*10,chars=None):
     if not os.path.exists(fp):
         return
     if os.path.isfile(fp):
         #print(f"remove file '{fp}'")
         if cover:
-            fcover(fp)
+            fcover(fp,wsize=wsize, chars=chars)
         os.remove(fp)
         return
     fps = os.listdir(fp)
@@ -123,4 +137,36 @@ def is_abs(fp):
     return False
 
 pass
-    
+    
+def xors(bs, codes):
+    if type(codes)==str:
+        codes = codes.encode("utf-8")
+    rst = b''
+    codes= list(codes)
+    for i in range(0, len(bs), len(codes)):
+        _bs = bs[i:i+len(codes)]
+        rs = bytes([a^b for a,b in zip(_bs, codes)])
+        rst+=rs
+        codes = codes[1:]+codes[:1]
+    return rst
+
+def fxors(fp, codes, ofp=None):
+    bs = read(fp, 'rb')
+    bs = xors(bs, codes)
+    if ofp is not None:
+        write(bs, ofp, 'wb')
+    else:
+        return bs
+
+pass
+def covers(dp, chars=None,wsize = 1024*10,):
+    if not os.path.exists(dp):
+        return
+    from . import lsf
+    fs = lsf.search(dp)
+    #print(f"fs: {fs}")
+    for fp in fs:
+        fcover(fp,wsize=wsize, chars=chars)
+
+pass
+fcovers = covers

buildz-0.6.47/buildz/iocz/base.py

@@ -0,0 +1,6 @@
+from ..base import Base, fcBase
+from .. import pathz
+path = pathz.Path()
+path.set('local', path.dir(__file__))
+path.set('conf', path.local('conf'),curr=0)
+

buildz-0.6.47/buildz/iocz/ioc/base.py

@@ -0,0 +1,14 @@
+from ..base import *
+basepath = path
+path = pathz.Path()
+path.set("conf", basepath.local("ioc/conf"), curr=0)
+
+class Creater(Base):
+    def init(self):
+        self.mg = None
+    def bind(self, mg):
+        self.mg = mg
+    def call(self, *a, **b):
+        return None
+
+pass

buildz-0.6.47/buildz/iocz/ioc/bind.py

@@ -0,0 +1,14 @@
+#
+from buildz import Base
+
+class Bind(Base):
+    def init(self):
+        self.mg = None
+        self.binds = []
+    def add_bind(self, fc):
+        self.binds.append(fc)
+    def bind(self, mg):
+        self.mg = mg
+        _ = [fc(mg) for fc in self.binds]
+
+pass