buildz 0.9.10__tar.gz → 0.9.12__tar.gz

{buildz-0.9.10/buildz.egg-info → buildz-0.9.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.10
+Version: 0.9.12
 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
@@ -28,6 +28,7 @@ Codes of this project are not allowed to be used for AI training or any other fo
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下
 3，其他工具模块：
     buildz.fz: 文件夹查找
+    buildz.log: 日志工具
     buildz.pyz: 简化python __import__调用
     buildz.argx: 按格式读命令行参数
     buildz.tz: 加些工具，目前只有myerse diff字符串比较算法

{buildz-0.9.10 → buildz-0.9.12}/README.md

@@ -15,6 +15,7 @@ Codes of this project are not allowed to be used for AI training or any other fo
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下
 3，其他工具模块：
     buildz.fz: 文件夹查找
+    buildz.log: 日志工具
     buildz.pyz: 简化python __import__调用
     buildz.argx: 按格式读命令行参数
     buildz.tz: 加些工具，目前只有myerse diff字符串比较算法

{buildz-0.9.10 → buildz-0.9.12}/buildz/_dz/conf.py

@@ -51,6 +51,17 @@ class BindKey(Base):
         return conf(self.key)
 
 pass
+'''
+
+实际数据：
+src: Conf对象，最底层，只读
+conf: dict数据，实际数据，可读可写
+history: dict里是list，每个key在push前，把当前key对应的数据存入history中，后面pop的时候，删除当前数据，把之前的数据重新更新
+_links: link对象，搜索方式是搜最长的有link的节点，返回link目标key拼接剩余key作为key的取值
+link对象：[{子集}, 当前节点link目标, 是否有link(1是，0否)]，初始化为[{}, None, 0]
+
+
+'''
 class Conf(Base):
     @staticmethod
     def bind_key(key, abs=True, up = None):

buildz-0.9.12/buildz/_dz/confx.py

@@ -0,0 +1,300 @@
+#
+
+'''
+简单的方便读取配置文件的类
+没安全措施
+每个Conf里有当前的数据conf，和数据是否存在exist
+可以执行的操作:
+读取，循环读取，修改，删除，修改和删除不会通知其他节点
+
+push和pop操作(耗时高)
+push修改当前conf的key
+生成修改记录
+
+pop的时候全改回来
+因为没用到，暂时不实现，只保留接口和数据
+
+gets可以获取多个key，返回队列
+top(domain)回到根节点的domain下
+call(domain)到当前节点的domain下，不存在或没有数据就报错
+
+Conf包含数据：
+conf: 实际数据
+exist: 数据是否存在
+domain: 根节点到当前节点的路径字符串
+spt,spts: 分割字符串
+src: 只读配置，默认为空
+root: 根节点
+
+
+
+'''
+
+from . import mapz
+from buildz import xf
+from ..base import Base
+import os
+def dzkeys(key, spt):
+    if key is None:
+        return []
+    elif type(key)==str:
+        key = key.split(spt)
+    elif type(key) not in (list, tuple):
+        key = [key]
+    return key
+
+class Conf(Base):
+    def len(self):
+        return len(self.conf)
+    def items(self, as_conf=True):
+        rst = []
+        for i in range(self.len()):
+            rst.append(self.list(i, as_conf))
+        return rst
+    def list(self, i, as_conf=True):
+        conf = self.conf[i]
+        if as_conf:
+            domain = self.domain+self.spt+str(i)
+            val = conf
+            src = self.src_list(i, as_conf)
+            obj = self.root or self
+            find = True
+            conf = Conf(self.spt, self.spts, domain, obj, src, val, find)
+        return conf
+    def lhget(self, key, default=None, loop=-1):
+        '''
+            循环读取，直到读取到的不是字符串或loop==0或没有对应的key了
+        '''
+        a,b = self._hget(key, default)
+        bak = a, b
+        obj = self.root or self
+        while b and type(a)==str and loop!=0:
+            a,b = obj._hget(a, default)
+            if b:
+                bak = a,b
+            loop-=1
+        if loop>0:
+            bak = a,b
+        return bak
+    def key(self, ks):
+        return self.spt.join(ks)
+    def src_list(self, i, as_conf = True):
+        if self.src is None:
+            return None
+        if self.src.get_type()!=list:
+            return None
+        if self.src.len()<=i:
+            return None
+        return self.src.list(i, as_conf)
+    def src_hget(self, key, default):
+        if self.src is None:
+            return default, 0
+        return self.src.hget(key, default, loop)
+    def src_dm(self, domain):
+        if self.src is None:
+            return None
+        return self.src(domain,0)
+    def src_top(self, domain):
+        if self.src is None:
+            return None
+        return self.src.top(domain, 0)
+    def lget(self, key, default=None, loop=-1):
+        return self.lhget(key, default, loop)[0]
+    def hget(self, key, default=None):
+        '''
+            最基本的读取方法
+            先从conf拿，没有则从src拿
+        '''
+        val, find = default, 0
+        keys = dzkeys(key, self.spt)
+        if self.exist and type(self.conf)==dict:
+            val, find = mapz.dget(self.conf, keys, default)
+        if find:
+            return val, find
+        return self.src_hget(keys, default)
+    def get(self, key, default=None):
+        val = self.hget(key, default)[0]
+        #print(f"get {key} = {val}")
+        return val
+    def has(self, key):
+        return self.hget(key, None)[1]
+    def remove(self, key):
+        if not self.exist or type(self.conf)!=dict:
+            return
+        keys = dzkeys(key, self.spt)
+        return mapz.dremove(self.conf, keys)
+    def spts_ks(self, keys):
+        '''
+            一堆key组成的字符串拆分成key的列表
+        '''
+        keys = dzkeys(keys, self.spts)
+        keys = [k.strip() if type(k) == str else k for k in keys]
+        return keys
+    def set(self, key, val):
+        keys = dzkeys(key, self.spt)
+        mapz.dset(self.conf, keys, val)
+    def top(self, domain = None, loop=0):
+        root = self.root or self
+        if domain is not None:
+            root = root(domain, loop)
+        return root
+    def l(self, domain=None, loop=-1):
+        return self(domain,loop)
+    def call(self, domain=None, loop=0):
+        '''
+            获取子域下的数据作为Conf
+        '''
+        if domain is None:
+            return self.root or self
+        val,find = self.hget(domain)
+        src = self.src_dm(domain)
+        if self.domain:
+            domain = self.domain+self.spt+domain
+        obj = self.root or self
+        bak = domain, val, find, src
+        while loop!=0 and find and type(val)==str:
+            bak = domain, val, find, src
+            val,find = obj.hget(domain)
+            src = self.src_top(domain)
+            loop-=1
+        domain,val,find,src=bak
+        return Conf(self.spt, self.spts, domain, obj, src, val, find)
+    def val(self):
+        return self.conf
+    def get_type(self):
+        return type(self.val())
+    def has_val(self):
+        return self.exist
+    def get_conf(self):
+        return self.conf
+    def str(self):
+        return str(self.get_conf())
+    def init(self, spt='.', spts=',', domain=None, root = None, src = None, conf=None, exist=1):
+        self.spt = spt
+        self.spts = spts
+        self.domain = domain
+        self.root = root
+        self.src = src
+        if conf is None:
+            conf = {}
+        self.conf = conf
+        self.exist = exist
+        self.history = {}
+    def clean(self):
+        '''
+            清空当前数据
+        '''
+        if self.get_type()!=dict:
+            return
+        self.history = {}
+        for key in self.conf:
+            del self.conf[key]
+        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 flush:
+            conf = xf.flush_maps(conf, lambda x:x.split(self.spt) if type(x)==str else [x], visit_list)
+        #print(f"update with {conf}")
+        xf.fill(conf, self.conf, replace=replace)
+        return self
+    def push(self, key, value, flush = 1, update=0, clean_history = 0):
+        if self.get_type()!=dict:
+            return None
+        keys = dzkeys(key, self.spt)
+        val, find = mapz.dget(self.conf, keys)
+        val = mapz.deep_clone(val)
+        if clean_history or key not in self.history:
+            self.history[key] = []
+        self.history[key].append([val, find, update])
+        if flush and type(value)==dict:
+            value = xf.flush_maps(value, lambda x:x.split(self.spt) if type(x)==str else [x], 0)
+        if find and type(value)==dict and type(val)==dict and update:
+            self(key).update(value,flush=0)
+        else:
+            self.set(key, value)
+        return key
+    def pop(self, key, clean_history = 0):
+        if key not in self.history:
+            return False
+        lst = self.history[key]
+        if len(lst)==0:
+            return False
+        rst = lst.pop(-1)
+        if clean_history:
+            self.history[key] = []
+        if not rst[1]:
+            self.remove(key)
+            return True
+        self.set(key, rst[0])
+        return True
+    def pops(self, keys, *a, **b):
+        keys = self.spts_ks(keys)
+        keys.reverse()
+        for key in keys:
+            self.pop(key)
+    def with_push(self, key, *a, **b):
+        self.push(key, *a, **b)
+        def out():
+            self.pop(key)
+        return pyz.with_out(out)
+    def with_pushs(self, keys, *a, **b):
+        self.pushs(keys, *a, **b)
+        def out():
+            self.pops(keys)
+        return pyz.with_out(out)
+    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):
+        keys = self.spts_ks(keys)
+        rst = [1-self.has(key) for key in keys]
+        return sum(rst)==0
+    def has_any(self, keys):
+        keys = self.spts_ks(keys)
+        for key in keys:
+            if self.has(key):
+                return True
+        return False
+    @staticmethod
+    def fcs_bind(fn, wfn, align=False, null_default= False):
+        def wfc(self, keys, *objs, **maps):
+            #print(f"[[[[[]]]]]{wfn} call by {id(self)}")
+            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(Conf, wfn, wfc)
+
+pass
+maps = xf.loads(r"""
+(get,0,1)
+(lget,0,1)
+(set,1)
+(remove)
+(push,1)
+""")
+for item in maps:
+    k = item[0]
+    ks = k+"s"
+    item = item[:1]+[ks]+item[1:]
+    Conf.fcs_bind(*item)
+
+pass

{buildz-0.9.10 → buildz-0.9.12}/buildz/argx.py

@@ -56,8 +56,16 @@ class Fetch:
                 for rkey in rkeys:
                     assert rkey!=key, f'error rkey==key: {key}'
                     val = rst[key]
-                    rst[rkey] = val
+                    if rkey not in rst:
+                        rst[rkey] = val
+                    else:
+                        tmp = rst[rkey]
+                        if type(tmp)!=list:
+                            tmp = [tmp]
+                            rst[rkey] = tmp
+                        tmp.append(val)
                     keys.append(rkey)
+                    keys = list(set(keys))
                 del rst[key]
         # for key in keys:
         #     while key in self.maps:

{buildz-0.9.10 → buildz-0.9.12}/buildz/base.py

@@ -60,7 +60,19 @@ class Base:
         return None
 
 pass
-
+class BaseX(Base):
+    def __iter__(self):
+        return self.iter()
+    def iter(self):
+        assert False
+    def __getattr__(self, key):
+        return self.get(key)
+    def get(self, key):
+        assert False
+    def set(self, key,val):
+        assert False
+    def __setattr__(self, key, val):
+        return self.set(key, val)
 class WBase(Base):
     def _open(self):
         pass

buildz-0.9.12/buildz/confx.py

@@ -0,0 +1,102 @@
+#
+from .base import Base
+class Confz(Base):
+    def init(self, fc_key = "fc", fn_key = "fn", objs="__confz.objs", fns = "__confz.fns", caches = "__confz.caches", fcs = "__confz.fcs", default_fn = "calls", obj_prefix = "", save_key = "save", default_save = True):
+        self.fc_key = fc_key
+        self.fn_key = fn_key
+        self.objs = objs
+        self.fns = fns
+        self.fcs = fcs
+        self.caches = caches
+        self.default_fn = default_fn
+        self.obj_prefix=  obj_prefix
+        self.default_save = default_save
+        self.save_key = save_key
+    def set(self, conf, id, obj, prefix=True):
+        '''
+            存放创建好的对象
+        '''
+        if prefix:
+            id = self.obj_prefix+id
+        conf(self.objs).set(id, obj)
+    def get(self, conf, id):
+        id = self.obj_prefix+id
+        objs = conf(self.objs)
+        obj = objs.get(id)
+        if obj is None:
+            obj = self.simple(conf, id)
+        return obj
+    def regist(self, curr, conf):
+        '''
+            fn: regist/reg
+            name: fn_name
+            path: fc_path
+            call: false
+        '''
+        name, path, call = curr.gets("name, path, call")
+        if not call:
+            fns = conf(self.fns)
+            fns.set(name, path)
+            return
+        fc = pyz.load(path)
+        fc = fc(curr, conf)
+        conf(self.fcs).set(name, fc)
+    def calls(self, curr, conf):
+        """
+            fn: calls
+            calls: [key1, key2, key3]
+        """
+        calls = curr.get("calls", [])
+        rst = [self.simple(conf, k) for k in calls]
+        return rst
+    def init(self, conf):
+        fcs = conf(self.fcs)
+        fcs.set("regist", self.regist)
+        fcs.set("reg", self.regist)
+        fcs.set("calls", self.calls)
+    def get_fc(self, curr, conf, default_fc):
+        s_fc = curr.get(self.fc_key, None)
+        if s_fc is not None:
+            return pyz.load(s_fc)
+        if default_fc is not None:
+            return default_fc
+        fn = curr.get(self,fn_key, self.default_fn)
+        fcs = conf(self.fcs)
+        fc = fcs.get(fn)
+        if fc is not None:
+            return fc
+        fns = conf(self.fns)
+        s_fc = fns.get(fn)
+        if s_fc is None:
+            return None
+        fc = pyz.load(s_fc)
+        fcs.set(fn, fc)
+        return fc
+    def simple(self, conf, key, default_fc = None):
+        curr = conf(key)
+        fc = self.get_fc(curr, conf, default_fc)
+        obj = fc(curr, conf)
+        if curr.get(self.save_key, self.default_save):
+            self.set(key, obj,False)
+        return obj
+    def call(self, conf, key, default_fc=None):
+        return self.simple(conf, key, default_fc)
+
+pass
+                
+def wrap(fc, to_dict=0, unwrap=0, put_conf=1):
+    if unwrap:
+        assert to_dict==1
+        assert put_conf==0
+    def wfc(curr, conf):
+        if to_dict:
+            curr = curr.dict()
+        if unwrap:
+            return fc(**curr)
+        elif not put_conf:
+            return fc(curr)
+        else:
+            return fc(curr, conf)
+    return wfc
+
+pass

{buildz-0.9.10 → buildz-0.9.12}/buildz/dz.py

@@ -2,4 +2,5 @@
 from ._dz.mapz import *
 from ._dz.omapz import Mapz
 from ._dz.conf import Conf, BindKey
+from ._dz.confx import Conf as Confx
 from ._dz.oconf import ObjConf, ObjTypeConf

{buildz-0.9.10 → buildz-0.9.12}/buildz/fz/__init__.py

@@ -4,6 +4,6 @@ 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, xors, fxors, coverx, covers, fcovers
 from .fhs import fhash, fhashs
-from .csv import to_csv, from_csv
+from .csv import to_csv, from_csv, merge_in
 
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

buildz-0.9.12/buildz/fz/csv.py

@@ -0,0 +1,159 @@
+#
+from . import fio
+"""
+col=1,as_map = 1
+{
+    a: [a1,a2,a3,...]
+    b: [b1,b2,b3,...]
+    ...
+}
+
+col=1, as_map=0
+[
+    [a1,a2,a3,...]
+    [b1,b2,b3,...]
+    ...
+]
+
+col=0,as_map = 1
+[
+    {a:a1,b:b1,...},
+    {a:a2,b:b2,...},
+    ...
+]
+
+col=0,as_map=0
+[
+    [a1,b1,...],
+    [a2,b2,...],
+    ...
+]
+"""
+def to_csv(keys, datas, fp, col = True, as_map = False,coding="utf-8"):
+    fio.makefdir(fp)
+    rst = []
+    if col:
+        if as_map:
+            datas = [datas[k] for k in keys]
+        datas = list(zip(*datas))
+    else:
+        if as_map:
+            datas = [[dt[k] for k in keys] for dt in datas]
+    datas = [", ".join([str(v) for v in dt]) for dt in datas]
+    rst = [", ".join(keys)]+datas
+    rs = "\n".join(rst)
+    fio.write(rs.encode(coding), fp)
+
+pass
+
+def from_csv(fp, col=True, as_map = False,coding="utf-8"):
+    s = fio.read(fp).decode(coding)
+    arr = s.split("\n")
+    arr = [[v.strip() for v in k.split(",")] for k in arr if k.strip()!=""]
+    keys = arr[0]
+    datas = arr[1:]
+    if col:
+        outs = []
+        for i in range(len(keys)):
+            tmp = [k[i] for k in datas]
+            outs.append(tmp)
+        if as_map:
+            outs = {k:arr for k,arr in zip(keys, datas)}
+        datas = outs
+    elif as_map:
+        datas = [{k:v for k,v in zip(keys, dt)} for dt in datas]
+    return keys, datas
+
+pass
+def wrap_cols(keys, cols):
+    rst = {}
+    for key, col in zip(keys, cols):
+        rst[key] = col
+    return rst
+
+def init_merge_keys(keys_a, keys_b):
+    rst = {}
+    keys_b = {k:k for k in keys_b}
+    for k in keys_a:
+        rst[k] = []
+    keys_b_ = {}
+    for k,v in keys_b.items():
+        while v in rst:
+            v = v+"_"
+        rst[v] = []
+        keys_b_[k] = v
+    keys_b = keys_b_
+    return rst, keys_b
+def merge_col_in(datas_a, datas_b, keys, keys_a = None, keys_b = None):
+    if type(keys)==str:
+        keys = [keys]
+    if keys_a is None:
+        keys_a = list(datas_a.keys())
+    bak_a = keys_a
+    keys_a = set(keys_a)
+    if keys_b is None:
+        keys_b = list(datas_b.keys())
+    bak_b = keys_b
+    keys_b = set(keys_b)
+    l = len(datas_b[keys[0]])
+    indexes = {}
+    for i in range(l):
+        vs = tuple([datas_b[k][i] for k in keys])
+        indexes[vs] = i
+    rst, keys_b = init_merge_keys(keys_a, keys_b)
+    l = len(datas_a[keys[0]])
+    for i in range(l):
+        vs = tuple([datas_a[k][i] for k in keys])
+        if vs not in indexes:
+            continue
+        j = indexes[vs]
+        for k in keys_a:
+            rst[k].append(datas_a[k][i])
+        for k, k_ in keys_b.items():
+            rst[k_].apepnd(datas_b[k][j])
+    return rst, [keys_a, keys_b]
+
+def merge_row_in(datas_a, datas_b, keys, keys_a = None, keys_b = None):
+    if type(keys)==str:
+        keys = [keys]
+    if len(datas_a)*len(datas_b)==0:
+        return []
+    if keys_a is None:
+        keys_a = list(datas_a[0].keys())
+    bak_a = keys_a
+    keys_a = set(keys_a)
+    if keys_b is None:
+        keys_b = list(datas_b[0].keys())
+    bak_b = keys_b
+    keys_b = set(keys_b)
+    rst, keys_b = init_merge_keys(keys_a, keys_b)
+    rst = []
+    l = len(datas_b)
+    indexes = {}
+    for i in range(l):
+        dt = datas_b[i]
+        vs = tuple([dt[k] for k in keys])
+        indexes[vs] = i
+    l = len(datas_a)
+    for i in range(l):
+        dt = datas_a[i]
+        vs = tuple([dt[k] for k in keys])
+        if vs not in indexes:
+            continue
+        j = indexes[vs]
+        tmp = {}
+        for k in keys_a:
+            tmp[k] = dt[k]
+        dt = datas_b[j]
+        for k, k_ in keys_b.items():
+            tmp[k_] = dt[k]
+        rst.append(tmp)
+    keys_b = [v for k,v in keys_b.items()]
+    return rst, [keys_a, keys_b]
+
+    
+def merge_in(datas_a, datas_b, keys, col = True, keys_a = None, keys_b = None):
+    if col:
+        return merge_col_in(datas_a, datas_b, keys, keys_a, keys_b)
+    return merge_row_in(datas_a, datas_b, keys, keys_a, keys_b)
+