buildz 0.9.1__tar.gz → 0.9.3__tar.gz

{buildz-0.9.1/buildz.egg-info → buildz-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.1
+Version: 0.9.3
 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.9.3/buildz/_dz/conf.py

@@ -0,0 +1,219 @@
+
+from . import mapz
+from buildz import xf
+from ..base import Base
+import os
+def dzkeys(key, spt):
+    if key is None:
+        return []
+    # return mapz.keys(key, spt)
+    if type(key)==str:
+        key = key.split(spt)
+    if type(key) not in (list, tuple):
+        key = [key]
+    return key
+class Conf(Base):
+    def val(self):
+        return self.get_conf()
+    def top(self, domain = None):
+        root = self.root or self
+        if domain is not None:
+            root = root(domain)
+        return root
+        # return self.root or self
+    def get_conf(self):
+        if self.domain:
+            key = self.domain
+        obj = self.root or self
+        if self.domain:
+            return obj._get(self.domain)
+        return obj.conf
+    def str(self):
+        return str(self.get_conf())
+    def call(self, domain=None):
+        if domain is None:
+            return self.top()
+        if self.domain:
+            domain = self.domain+self.spt+domain
+        obj = self.root or self
+        return Conf(self.spt, self.spts, domain, obj)
+    def init(self, spt='.', spts=',', domain=None, root = None):
+        self.spt = spt
+        self.spts = spts
+        self.domain = domain
+        self.root = root
+        if root is None:
+            self.conf = {}
+            self.stacks = {}
+            self._links = [{},None]
+        self.dr_bind('_get', 'get')
+        self.dr_bind('_hget', 'hget')
+        self.dr_bind('_set', 'set')
+        self.dr_bind('_has', 'has')
+        self.dr_bind('_remove', 'remove')
+        self.dr_bind('_link', 'link')
+        self.dr_bind('_unlink', 'unlink')
+        self.dr_bind('_push', 'push')
+        self.dr_bind('_pop', 'pop')
+        self.dr_bind('_stack_set', 'stack_set')
+        self.dr_bind('_stack_unset', 'stack_unset')
+        self.fcs_bind('get', 'gets', False, True)
+        self.fcs_bind('set', 'sets', True)
+        self.fcs_bind('remove', 'removes')
+        self.fcs_bind('push', 'pushs', True)
+        self.fcs_bind('pop', 'pops')
+        self.fcs_bind('stack_set', 'stack_sets', True)
+        self.fcs_bind('stack_unset', 'stack_unsets')
+        self.fcs_bind('link', 'links', True)
+        self.fcs_bind('unlink', 'unlinks')
+        for name,rename in zip("stack_set,stack_unset,stack_sets,stack_unsets".split(","), "tmp_set,tmp_unset,tmp_sets,tmp_unsets".split(',')):
+            setattr(self, rename, getattr(self, name))
+        self.have_all = self.has_all
+    def clean(self):
+        obj = self.root or self
+        obj.conf = {}
+        obj.stacks = {}
+        obj._links = [{}, None]
+        return self
+    def dkey(self, key):
+        if self.domain:
+            key = self.domain+self.spt+key
+        return key
+    def update(self, conf, flush = 1, replace=1, visit_list=0):
+        if self.domain:
+            ks = dzkeys(self.domain, self.spt)
+            tmp = {}
+            mapz.dset(tmp, ks, conf)
+            conf = tmp
+        if self.root:
+            return self.root.update(conf, flush, replace, visit_list)
+        if flush:
+            conf = xf.flush_maps(conf, lambda x:x.split(self.spt) if type(x)==str else [x], visit_list)
+        xf.fill(conf, self.conf, replace=replace)
+        return self
+    def dr_bind(self, fn, wfn):
+        def wfc(key,*a,**b):
+            key = self.dkey(key)
+            obj = self.root or self
+            fc = getattr(obj, fn)
+            return fc(key, *a, **b)
+        setattr(self, wfn, wfc)
+    def fcs_bind(self, fn, wfn, align=False, null_default= False):
+        def wfc(keys, *objs, **maps):
+            keys = self.spts_ks(keys)
+            fc = getattr(self, fn)
+            rst = []
+            for i in range(len(keys)):
+                if i<len(objs):
+                    val = fc(keys[i], objs[i], **maps)
+                else:
+                    if align:
+                        raise Exception(f"not val[{i}]")
+                    if null_default:
+                        val = fc(keys[i], None, **maps)
+                    else:
+                        val = fc(keys[i], **maps)
+                rst.append(val)
+            return rst
+        setattr(self, wfn, wfc)
+    def _stack_set(self, key, val):
+        if key not in self.stacks:
+            self.stacks[key] = []
+        self.stacks[key] = [val]
+    def _stack_unset(self, key, val):
+        if key not in self.stacks:
+            return False
+        del self.stacks[key]
+        return True
+    def _push(self, key, val):
+        if key not in self.stacks:
+            self.stacks[key] = []
+        self.stacks[key].append(val)
+    def _pop(self, key):
+        if key not in self.stacks:
+            return False
+        stk = self.stacks[key]
+        if len(stk)==0:
+            return False
+        stk.pop(-1)
+        return True
+    def _link(self, src, target):
+        keys = dzkeys(src, self.spt)
+        links = self._links
+        for key in keys:
+            if key not in links[0]:
+                links[0][key] = [{},None]
+            links = links[0][key]
+        links[1] = target
+    def _unlink(self, key):
+        keys = dzkeys(key, self.spt)
+        links = self._links
+        for key in keys:
+            if key not in links[0]:
+                return False
+            links = links[0][key]
+        links[1] = None
+        return True
+    def link_match(self, keys):
+        obj = self.root or self
+        links = obj._links
+        deep = 0
+        for key in keys:
+            if key not in links[0]:
+                break
+            deep+=1
+            links = links[0][key]
+        return links[1], deep
+    def _set(self, key, val):
+        keys = dzkeys(key, self.spt)
+        mapz.dset(self.conf, keys, val)
+    def _hget(self, key, default=None, loop=-1):
+        #print(f"_hget: {key}, {default}, {loop}")
+        stk = mapz.get(self.stacks, key, [])
+        if len(stk)>0:
+            return stk[-1],1
+        keys = dzkeys(key, self.spt)
+        val, find = mapz.dget(self.conf, keys, default)
+        if find or loop==0:
+            return val, find
+        lnk, deep = self.link_match(keys)
+        if lnk is None:
+            return val, find
+        keys = keys[deep:]
+        keys = self.spt.join(keys)
+        key = lnk+self.spt+keys
+        if loop>0:
+            loop-=1
+        return self._hget(key, default, loop)
+    def _get(self, key, default=None, loop=-1):
+        return self._hget(key, default,loop)[0]
+        keys = dzkeys(key, self.spt)
+        return mapz.dget(self.conf, keys, default)[0]
+    def _remove(self, key):
+        keys = dzkeys(key, self.spt)
+        return mapz.dremove(self.conf, keys)
+    def _has(self, key, loop=0):
+        return self._hget(key, None, loop)[1]
+        keys = dzkeys(key, self.spt)
+        return mapz.dhas(self.conf, keys)
+    def spts_ks(self, keys):
+        keys = dzkeys(keys, self.spts)
+        keys = [k.strip() if type(k) == str else k for k in keys]
+        return keys
+    def g(self, **maps):
+        rst = [self.get(k, v) for k,v in maps.items()]
+        if len(rst)==1:
+            rst = rst[0]
+        return rst
+    def s(self, **maps):
+        [self.set(k,v) for k,v in maps.items()]
+    def has_all(self, keys, loop = 0):
+        keys = self.spts_ks(keys)
+        rst = [1-self.has(key, loop) for key in keys]
+        return sum(rst)==0
+    def has_any(self, keys, loop=0):
+        keys = self.spts_ks(keys)
+        for key in keys:
+            if self.has(key, loop):
+                return True
+        return False

{buildz-0.9.1 → buildz-0.9.3}/buildz/_dz/mapz.py

@@ -213,6 +213,30 @@ def dget(maps, keys, default = None):
     return maps,1
 
 pass
+def dmatch(maps, keys, fc_map = lambda x:x):
+    if type(keys) not in (list,tuple):
+        keys = [keys]
+    deep=0
+    src = maps
+    for key in keys:
+        find = 1
+        maps = fc_map(maps)
+        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:
+            break
+        deep+=1
+        src = maps[key]
+    return src,deep
+
 def dremove(maps, keys):
     if type(keys) not in (list,tuple):
         keys = [keys]

{buildz-0.9.1 → buildz-0.9.3}/buildz/argx.py

@@ -36,6 +36,8 @@ class Fetch:
         return rst
     def __call__(self, argv = None):
         args, maps = fetch(argv)
+        return self.fetch(args, maps)
+    def fetch(self, args, maps):
         rst = {}
         for i in range(len(args)):
             if i >= len(self.args):

{buildz-0.9.1 → buildz-0.9.3}/buildz/confz.py

@@ -29,30 +29,38 @@ def calls(conf):
     root = conf.top()
     if type(calls)==dict:
         target = dz.g(calls, target='run')
-        if target in calls:
-            calls = dz.get(calls, target, [])
-        else:
-            calls = root.get(target, [])
+        calls = dz.get(calls, target, [])
+        # if target in calls:
+        #     calls = dz.get(calls, target, [])
+        # else:
+        #     calls = root.get(target, [])
     if type(calls)==dict:
-        dm, init, calls = dz.g(calls, domain=None, init = {},calls=[])
+        dm, init, calls, init_cover = dz.g(calls, domain=None, init = {},calls=[], init_cover=False)
         if len(init)>0:
             init_conf = conf.top("confz.init")
             if dm is not None:
                 init_conf = init_conf(dm)
-            init_conf.update(init, replace=0)
+            init_conf.update(init, replace=init_cover)
             root.update(init_conf.val())
     if type(calls)==str:
         calls = [calls]
     for key in calls:
         assert conf.has(key), f"not has key: '{key}'"
         simple(conf(key))
+    return conf
 def simple(conf):
     fc = conf.get('fc')
+    up = conf.get('up', loop=0)
+    if up:
+        conf().link(conf.domain, up)
     if fc is None:
         fc = calls
     else:
+        # import time
+        # print(time.strftime(f"%Y-%m-%d %H:%M:%S start load: {fc}"))
         #assert fc is not None
         fc = pyz.load(fc)
+        # print(time.strftime(f"%Y-%m-%d %H:%M:%S done load: {fc}"))
     return fc(conf)
 def get_sys_conf(conf = []):
     if type(conf) == str:
@@ -75,8 +83,8 @@ def run(dp = None, fp = None, init_conf = {}):
     init = conf.get(conf.get("key.init", "init"), {})
     conf = load_conf(conf, dp).update(init)
     conf.set("confz.init", init)
-    simple(conf)
-    return conf
+    return simple(conf)
+    #return conf
 def test():
     run()
 pyz.lc(locals(), test)

buildz-0.9.3/buildz/jv/confz/Test.javap

@@ -0,0 +1,25 @@
+
+import com.buildz.xf.Loader;
+import java.util.Map;
+import com.buildz.Confz;
+import com.buildz.Conf;
+public class Test {
+    public static Object test(Conf conf) {
+        System.out.println("call in test:"+conf.toString());
+        return null;
+    }
+    public static void main(String[] args)throws Exception {
+        Object obj = Confz.run("fps.js");
+        System.out.println("obj:"+obj);
+        String s = "{a.b.c=d,x=y,test.x.y..z=123}";
+        Loader jni = new Loader();
+        Map rst = (Map)jni.loads(s);
+        Conf conf = new Conf();
+        System.out.println("conf:"+conf);
+        conf.update(rst);
+        //conf.set("test.x.y..z", 123);
+        Conf sub = conf.sub("test");
+        System.out.println("sub:"+sub);
+
+    }
+}

buildz-0.9.3/buildz/jv/confz/build

@@ -0,0 +1,7 @@
+./clean
+python -m buildz.jv.jvp.main .
+./jvc com/buildz/Utils.java
+./jvc com/buildz/ConfUtil.java
+./jvc com/buildz/Conf.java
+./jvc com/buildz/Confz.java 
+./jvc Test.java

buildz-0.9.3/buildz/jv/confz/build.bat

@@ -0,0 +1,6 @@
+python -m buildz.jv.jvp.main .
+jvc.bat com/buildz/Utils.java
+jvc.bat com/buildz/ConfUtil.java
+jvc.bat com/buildz/Conf.java
+jvc.bat com/buildz/Confz.java 
+jvc.bat Test.java

buildz-0.9.3/buildz/jv/confz/clean

@@ -0,0 +1,5 @@
+rm ./com/buildz/*.class
+rm ./com/buildz/xf/*.class
+rm ./com/buildz/*.java
+rm ./*.class
+rm ./*.java

buildz-0.9.3/buildz/jv/confz/clean.bat

@@ -0,0 +1,5 @@
+del com\buildz\*.class
+del com\buildz\xf\*.class
+del *.class
+del *.java
+del com\buildz\*.java

buildz-0.9.3/buildz/jv/confz/com/buildz/Conf.javap

@@ -0,0 +1,266 @@
+package com.buildz;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+class Link{
+    public Map<String, Link> maps=new HashMap<>();
+    public String val=null;
+    public Link(){}
+}
+class LinkMatch{
+    public String val;
+    public int deep;
+    public LinkMatch(String val, int deep){
+        this.val = val;
+        this.deep=deep;
+    }
+}
+public class Conf{
+    public static Object[] args(Object... vars){
+        return vars;
+    }
+    public String toString(){
+        return val().toString();
+    }
+    public <T> T getObj(Class<T> targetClass) {
+        try{
+            return ConfUtil.fill(this, targetClass);
+        }catch (Exception exp){
+            throw new RuntimeException(""+exp);
+        }
+    }
+    public Map<String, Object> conf=null;
+    Conf root=null;
+    Map<String, List> stacks=null;
+    Link _links=null;
+    public String spt;
+    public String spts;
+    public String domain;
+    <<default(".", ",", null, null)||Conf>>
+    public Conf(String spt, String spts, String domain, Conf root) {
+        this.spt = spt;
+        this.spts = spts;
+        this.domain = domain;
+        this.root = root;
+        if (root==null) {
+            conf = new HashMap<>();
+            stacks = new HashMap<>();
+            _links = new Link();
+        }
+    }
+    <<default(null)||top>>
+    public Conf top(String domain){
+        Conf obj = this;
+        if (root!=null)obj =root;
+        if (domain!=null) {
+            obj = obj.sub(domain);
+        }
+        return obj;
+    }
+    <<rename(val)||getConf>>
+    public Map getConf(){
+        Conf obj = top();
+        if (domain!=null) {
+            return (Map)obj._get(domain);
+        }
+        return obj.conf;
+    }
+    public Conf sub(String domain) {
+        domain = dmKey(domain);
+        root = top();
+        return new Conf(spt, spts, domain, root);
+    }
+    public Conf clean(){
+        if (root!=null) {
+            root.clean();
+            return this;
+        }
+        conf = new HashMap<>();
+        stacks = new HashMap<>();
+        _links = new Link();
+        return this;
+    }
+    public String dmKey(String key){
+        if (domain !=null) {
+            key = domain+spt+key;
+        }
+        return key;
+    }
+    <<default(true,true)||
+    public Conf update(Map<String, Object> conf, boolean flush, boolean replace) {
+        if (conf==null)return this;
+        if (domain!=null) {
+            String[] ks = Utils.keys(domain, spt);
+            Map tmp = new HashMap();
+            Utils.dset(tmp, ks, conf);
+            conf = tmp;
+        }
+        if (root!=null) {
+            root.update(conf, flush, replace);
+            return this;
+        }
+        if (flush) {
+            conf = Utils.flushMaps(conf, spt);
+        }
+        Utils.fill(conf, this.conf, replace);
+        return this;
+    }>>
+    <<methods(stackSets,true)||domain(stackSet)||
+    public void _stackSet(String key, Object value) {
+        List list = new ArrayList();
+        list.add(value);
+        stacks.put(key, list);
+    }>>
+    <<methods(stackUnsets,ret=0)||domain(stackUnset)||
+    public boolean _stackUnset(String key) {
+        if (!stacks.containsKey(key)) {
+            return false;
+        }
+        stacks.remove(key);
+        return true;
+    }>>
+    <<rename(tmpSet)||stackSet>>
+    <<rename(tmpUnset)||stackUnset>>
+    <<rename(tmpSets)||stackSets>>
+    <<rename(tmpUnsets)||stackUnsets>>
+    <<methods(pushs,val=true)||domain(push)||
+    public void _push(String key, Object value) {
+        if (!stacks.containsKey(key)) {
+            stacks.put(key, new ArrayList());
+        }
+        List list = (List)stacks.get(key);
+        list.add(value);
+    }>>
+    <<methods(pops,ret=1)||domain(pop)||
+    public boolean _pop(String key) {
+        if (!stacks.containsKey(key)) {
+            return false;
+        }
+        List list = stacks.get(key);
+        if (list.size()==0)return false;
+        list.remove(list.size()-1);
+        return true;
+    }>>
+    <<domain(link)||_link>>
+    <<methods(links,val=true,ret=false,align=true)||link>>
+    public void _link(String src, String target) {
+        String[] keys = Utils.keys(src, spt);
+        Link links = this._links;
+        for (String key:keys) {
+            if (!links.maps.containsKey(key)) {
+                links.maps.put(key, new Link());
+            }
+            links = links.maps.get(key);
+        }
+        links.val = target;
+    }
+    <<methods(unlinks)||domain(unlink)||_unlink>>
+    public boolean _unlink(String key) {
+        String[] keys = sptKeys(key);
+        Link links = this._links;
+        for (String _key:keys) {
+            if (!links.maps.containsKey(_key)) {
+                return false;
+            }
+            links = links.maps.get(_key);
+        }
+        links.val = null;
+        return true;
+    }
+    private LinkMatch linkMatch(String[] keys) {
+        Conf obj = top();
+        Link links = obj._links;
+        int deep=0;
+        for(String key:keys){
+            if (!links.maps.containsKey(key)){
+                break;
+            }
+            deep+=1;
+            links = links.maps.get(key);
+        }
+        return new LinkMatch(links.val,deep);
+    }
+    <<methods(sets,val=true,ret=false,align=true)||domain(set)||
+    public void _set(String key, Object value) {
+        String[] keys = sptKeys(key);
+        // System.out.println("[XXX] set.key:"+key);
+        // System.out.println("[XXX] set.keys:"+keys.length);
+        Utils.dset(this.conf, keys, value);
+    }>>
+    <<||->||domain(hget)->default(null,-1,-1)->
+    public Result _hget(String key, Object def, int loop, int stack){
+        Result rst = new Result();
+        if (stack!=0&&stacks.containsKey(key)){
+            List list = stacks.get(key);
+            if (list.size()>0){
+                rst.val = list.get(list.size()-1);
+                rst.find=true;
+                return rst;
+            }
+        }
+        String[] keys = sptKeys(key);
+        Utils.dget(conf, keys, def, rst);
+        if (rst.find || loop==0){
+            return rst;
+        }
+        LinkMatch match = linkMatch(keys);
+        if (match.val ==null) {
+            return rst;
+        }
+        keys = Arrays.copyOfRange(keys, match.deep, keys.length);
+        key = String.join(spt, keys);
+        if (loop>0)loop-=1;
+        if (stack>0)stack-=1;
+        return _hget(key, def, loop, stack);
+    }>>
+    <<methods(gets, Object, true, false,'null')||domain(get)||default(null,-1,-1)||
+    public Object _get(String key, Object def, int loop, int stack) {
+        return _hget(key, def, loop, stack).val;
+    }>>
+    <<default(-1,-1)||
+    public <T> T wget(String key, T def, int loop, int stack) {
+        Object val = get(key, def, loop, stack);
+        return (T) val;
+    }>>
+    <<default(null, -1,-1)||
+    public <T> T tget(String key, Class<T> type, T def, int loop, int stack) {
+        Object val = get(key, def, loop, stack);
+        return (T) val;
+    }>>
+    <<methods(removes)||domain(remove)||
+    public boolean _remove(String key) {
+        String[] keys = sptKeys(key);
+        return Utils.dremove(conf, keys);
+    }>>
+    <<domain(has)||default(0,0)||
+    public boolean _has(String key, int loop, int stack){
+        return _hget(key, null, loop, stack).find;
+    }>>
+    public String[] sptKeys(String key){
+        return Utils.keys(key, spt);
+    }
+    public String[] sptsKeys(String keys) {
+        String[] ks = Utils.keys(keys, spts);
+        for(int i=0;i<ks.length;i++){
+            ks[i] = ks[i].trim();
+        }
+        return ks;
+    }
+    public boolean hasAll(String keys, int loop, int stack) {
+        String[] ks = sptsKeys(keys);
+        for(String key:ks) {
+            if (!has(key,loop,stack))return false;
+        }
+        return true;
+    }
+    public boolean hasAny(String keys, int loop, int stack) {
+        String[] ks = sptsKeys(keys);
+        for(String key:ks) {
+            if (has(key,loop,stack))return true;
+        }
+        return false;
+    }
+}