buildz 0.9.2__tar.gz → 0.9.3__tar.gz

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

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

@@ -200,29 +200,13 @@ class Conf(Base):
         keys = dzkeys(keys, self.spts)
         keys = [k.strip() if type(k) == str else k for k in keys]
         return keys
-    # def gets(self, keys, *defaults):
-    #     keys = self.spts_ks(keys)
-    #     rst = []
-    #     for i in range(len(keys)):
-    #         val = self.get(keys[i], defaults[i] if i<len(defaults) else None)
-    #         rst.append(val)
-    #     return rst
-    # def pushs(self, keys, *vals):
-    #     keys = self.spts_ks(keys)
-    #     rst = [self.push(key, val) for key, val in zip(keys, vals)]
-    # def pops(self, keys):
-    #     keys = self.spts_ks(keys)
-    #     return [self.pop(key) for key in keys]
     def g(self, **maps):
-        return [self.get(k, v) for k,v in maps.items()]
+        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 sets(self, keys, *vals):
-    #     keys = self.spts_ks(keys)
-    #     rst = [self.set(key, val) for key, val in zip(keys, vals)]
-    # def removes(self, keys):
-    #     keys = self.spts_ks(keys)
-    #     rst = [self.remove(key) for key in keys]
     def has_all(self, keys, loop = 0):
         keys = self.spts_ks(keys)
         rst = [1-self.has(key, loop) for key in keys]

{buildz-0.9.2 → 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.2 → buildz-0.9.3}/buildz/confz.py

@@ -29,23 +29,25 @@ 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)
@@ -81,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;
+    }
+}

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

@@ -0,0 +1,127 @@
+package com.buildz;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Map;
+import java.util.List;
+import java.util.ArrayList;
+import java.lang.reflect.Array;
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface Fill {
+    String key();
+    boolean need() default false;
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface Key {
+    String value();
+}
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface Need {
+    boolean value() default true;
+}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+@interface Source {
+}
+public class ConfUtil {
+    
+    public static <T> T fill(Conf conf, Class<T> targetClass) 
+            throws IllegalAccessException, InstantiationException, 
+                   NoSuchMethodException, InvocationTargetException,
+                   IllegalArgumentException {
+        
+        T instance = targetClass.getDeclaredConstructor().newInstance();
+        Field[] fields = targetClass.getDeclaredFields();
+        
+        for (Field field : fields) {
+            field.setAccessible(true);
+            
+            if (field.isAnnotationPresent(Source.class)) {
+                field.set(instance, conf);
+                continue;
+            }
+            String fieldName = field.getName();
+            boolean need=false;
+            
+            if (field.isAnnotationPresent(Fill.class)) {
+                Fill note = field.getAnnotation(Fill.class);
+                fieldName = note.key();
+                need = note.need();
+            }
+            if (field.isAnnotationPresent(Need.class)) {
+                Need note = field.getAnnotation(Need.class);
+                need = note.value();
+            }
+            if (field.isAnnotationPresent(Key.class)) {
+                Key note = field.getAnnotation(Key.class);
+                fieldName = note.value();
+            }
+            
+            if (conf.has(fieldName)) {
+                Object value = conf.get(fieldName);
+                Class<?> fieldType = field.getType();
+                
+                // 处理基本类型和包装类型的兼容性
+                if (value != null && !fieldType.isInstance(value)) {
+                    value = convertType(value, fieldType);
+                }
+                
+                field.set(instance, value);
+            } else {
+                if (need){
+                    throw new RuntimeException("can't find required key: '"+fieldName+"'");
+                }
+            }
+        }
+        return instance;
+    }
+    
+    private static Object convertType(Object value, Class<?> targetType) {
+        if (targetType == int.class || targetType == Integer.class) {
+            return ((Number) value).intValue();
+        } else if (targetType == long.class || targetType == Long.class) {
+            return ((Number) value).longValue();
+        } else if (targetType == double.class || targetType == Double.class) {
+            return ((Number) value).doubleValue();
+        } else if (targetType == boolean.class || targetType == Boolean.class) {
+            return Boolean.parseBoolean(value.toString());
+        } else if (targetType == List.class) {
+            if (value instanceof List) {
+                return value;
+            }
+            List rst = new ArrayList(1);
+            rst.add(value);
+            return rst;
+        } else if (targetType == Map.class) {
+            if (value instanceof Map) {
+                return value;
+            } else {
+                throw new RuntimeException("required Map but get:"+value.toString());
+            }
+        }else if (targetType.isArray()) {
+            Class<?> itemType = targetType.getComponentType();
+            Object newArray;
+            if (value instanceof List) {
+                List lst = (List)value;
+                newArray = Array.newInstance(itemType, lst.size());
+                for(int i=0;i<lst.size();i++) {
+                    Array.set(newArray, i, lst.get(i));
+                }
+            } else {
+                if (value != null && !itemType.isInstance(value)) {
+                    value = convertType(value, itemType);
+                }
+                newArray = Array.newInstance(itemType, 1);
+                Array.set(newArray, 0, value);
+            }
+            return newArray;
+        }
+        return value; // 无法转换时返回原值
+    }
+}

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

@@ -0,0 +1,144 @@
+package com.buildz;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import com.buildz.xf.Loader;
+import java.util.regex.Pattern;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.Path;
+import java.lang.reflect.Method;
+public class Confz{
+    public static Loader jni = new Loader();
+    <<default("utf-8")||loadf>>
+    public static Object loadf(String filepath, String encoding){
+        return loadf(Paths.get(filepath), encoding);
+    }
+    public static Object loadf(Path filepath, String encoding) {
+        try{
+            String content = new String(Files.readAllBytes(filepath), encoding);
+            return jni.loads(content);
+        } catch (Exception exp) {
+            throw new RuntimeException("loadf exp");
+        }
+    }
+    <<default(null,"dp", "src.conf")||loadConf>>
+    public static Conf loadConf(Map conf, String dp, String dpKey, String srcKey) {
+        Conf obj = new Conf();
+        obj.update(conf);
+        return loadConf(obj, dp, dpKey, srcKey);
+    }
+    public static Conf loadConf(Conf conf, String dp, String dpKey, String srcKey) {
+        class Param{
+            public String[] fps;
+            @Key("conf")
+            public Map base;
+            public boolean conf_first=true,replace=true,flush=true;
+            public String spt=".",spts=",";
+            public String dp;
+        }
+        Param p = conf.getObj(Param.class);
+        p.dp = conf.wget(dpKey, dp);
+        Conf rst = new Conf(p.spt, p.spts);
+        if (srcKey!=null) {
+            rst.set(srcKey, conf);
+        }
+        if (p.conf_first) {
+            rst.update(p.base, p.flush, p.replace);
+        }
+        for(String fp:p.fps) {
+            Map tmp = (Map)loadf(Paths.get(dp, fp));
+            rst.update(tmp, p.flush, p.replace);
+        }
+        if (!p.conf_first) {
+            rst.update(p.base, p.flush, p.replace);
+        }
+        return rst;
+    }
+    public static Object calls(Conf conf){
+        Object calls = conf.get("calls", new ArrayList());
+        Conf root = conf.top();
+        Conf sub = conf;
+        if (calls instanceof Map) {
+            sub = sub.sub("calls");
+            String target = sub.wget("target", "run");
+            calls = sub.get(target, new ArrayList());
+            sub = sub.sub(target);
+        }
+        if (calls instanceof Map) {
+            String dm = (String)sub.get("domain");
+            Map init = (Map)sub.get("init");
+            if (init!=null) {
+                Conf init_conf = conf.top("confz.init");
+                if (dm!=null){
+                    init_conf = init_conf.sub(dm);
+                }
+                init_conf.update(init, true, false);
+                root.update(init_conf.val());
+            }
+        }
+        if (calls instanceof String) {
+            List tmp = new ArrayList(1);
+            tmp.add(calls);
+            calls = tmp;
+        }
+        for(String key:(List<String>)calls) {
+            if (!conf.has(key))throw new RuntimeException("not key:"+key);
+            simple(conf.sub(key));
+        }
+        return conf;
+    }
+    public static Object simple(String fp) {
+        Map map = (Map)loadf(fp);
+        return simple(map);
+    }
+    public static Object simple(Map map) {
+        return simple(new Conf().update(map));
+    }
+    public static Object simple(Conf conf) {
+        String fc = (String)conf.get("fc");
+        String up = (String) conf.get("up", null, 0);
+        if (up!=null) {
+            conf.top().link(conf.domain, up);
+        }
+        if (fc==null){
+            return calls(conf);
+        }
+        try{
+            String[] arr = fc.split(Pattern.quote("."));
+            String methodName = arr[arr.length-1];
+            arr = Arrays.copyOfRange(arr, 0, arr.length-1);
+            String className = String.join(".", arr);
+            Class<?> clazz = Class.forName(className);
+            Method method = clazz.getMethod(methodName, Conf.class);
+            return method.invoke(null, conf);
+        }catch (Exception exp) {
+            throw new RuntimeException("simple call "+fc+" exp:"+exp);
+        }
+    }
+    <<default(".", new HashMap())||
+    public static Object run(String fp, String dp, Map init_conf) {
+        if (dp==null) {
+            dp = ".";
+        }
+        Map conf = new HashMap();
+        if (fp!=null) {
+            conf = (Map)loadf(Paths.get(dp, fp));
+        }
+        Conf confObj = new Conf().update(conf);
+        if (init_conf!=null){
+            confObj.update(init_conf);
+        }
+        Map init = confObj.wget(confObj.wget("key.init", "init"), new HashMap());
+        confObj = loadConf(confObj, dp);
+        confObj.update(init);
+        return simple(confObj);
+    }>>
+    <<default(".", null)||
+    public static Object run(Map init_conf, String dp, String fp){
+        return run(fp, dp, init_conf);
+    }>>
+}