buildz 0.9.9__tar.gz → 0.9.11__tar.gz

{buildz-0.9.9/buildz.egg-info → buildz-0.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.9
+Version: 0.9.11
 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.9 → buildz-0.9.11}/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.9 → buildz-0.9.11}/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.11/buildz/_dz/confx.py

@@ -0,0 +1,274 @@
+#
+
+'''
+简单的方便读取配置文件的类
+没安全措施
+每个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
+        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):
+        assert 0
+        return key
+    def pop(self, key, clean_history = 0):
+        assert 0
+    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.11/buildz/_dz/oconf.py

@@ -0,0 +1,89 @@
+class ObjConf:
+    def __str__(self):
+        return str(self._maps)
+    def __repr__(self):
+        return self.__str__()
+    def __init__(self):
+        self._maps = {}
+    def __getitem__(self, key):
+        return self._maps[key]
+    def __getattr__(self, key):
+        if key in self._maps:
+            return self._maps[key][0]
+        return self.__getattribute__(key)
+    def __setattr__(self, key, val):
+        if key != '_maps':
+            self(key, val)
+        else:
+            object.__setattr__(self,key,val)
+    def __call__(self, *args, **maps):
+        '''
+            call(key,val)
+            or
+            call(key0=val0, key1=val1)
+        '''
+        if len(args)==2:
+            key,val = args
+            self._maps[key] = val
+        else:
+            for key,val in maps.items():
+                self._maps[key] = val
+    def __delattr__(self, key):
+        if key in self._maps:
+            del self._maps[key]
+        return super().__delattr__(key)
+    def __contains__(self, key):
+        return self._maps.__contains__(key)
+
+pass
+
+class ObjTypeConf(ObjConf):
+    def __init__(self, vtype=0):
+        super().__init__()
+        self._vtypes = {}
+        self._vtype = vtype
+    def __getitem__(self, vtype=None):
+        if vtype is None:
+            return self._maps
+        maps = {}
+        for key in self._maps:
+            _vtype = self._vtypes[key]
+            if _vtype==vtype:
+                maps[key]=self._maps[key]
+        return maps
+    def __setattr__(self, key, val):
+        if key not in {'_maps','_vtype','_vtypes'}:
+            self(key, val)
+        else:
+            object.__setattr__(self,key,val)
+    def __call__(self, *args, **maps):
+        '''
+            call(key,val)
+            call(key,val,vtype)
+            or
+            call(key0=val0, key1=val1)
+        '''
+        if len(maps)==0:
+            if len(args)<=1:
+                return self.__getitem__(*args)
+        if len(args) in {2,3}:
+            key = args[0]
+            val = args[1]
+            vtype = None
+            if len(args)==3:
+                vtype = args[2]
+            vtype = vtype or self._vtype
+            self._maps[key] = val
+            self._vtypes[key] = vtype
+        else:
+            for key,val in maps.items():
+                self._maps[key] = val
+                self._vtypes[key] = self._vtype
+    def __delattr__(self, key):
+        if key in self._maps:
+            del self._maps[key]
+            del self._vtypes[key]
+            return
+        return super().__delattr__(key)
+
+pass

{buildz-0.9.9 → buildz-0.9.11}/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.11/buildz/dz.py

@@ -0,0 +1,6 @@
+
+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.9 → buildz-0.9.11}/buildz/fz/__init__.py

@@ -4,5 +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
 
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

buildz-0.9.11/buildz/fz/csv.py

@@ -0,0 +1,36 @@
+#
+from . import fio
+def to_csv(keys, cols, fp):
+    assert len(keys)==len(cols)
+    fio.makefdir(fp)
+    keys = ", ".join(keys)
+    rst = [keys]
+    for tmp in zip(*cols):
+        tmp = [str(k) for k in tmp]
+        tmp = ", ".join(tmp)
+        rst.append(tmp)
+    rs = "\n".join(rst)
+    fio.write(rs.encode("utf-8"), fp)
+
+pass
+
+def from_csv(fp, col=True, as_map = False):
+    # 好像还没测试
+    s = fio.read(fp).decode("utf-8")
+    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:
+        datas = []
+        for i in range(len(keys)):
+            tmp = [k[i] for k in datas]
+            datas.append(tmp)
+        if as_map:
+            datas = {k:arr for k,arr in zip(keys, datas)}
+    elif as_map:
+        datas = [{k:v for k,v in zip(keys, dt)} for dt in datas]
+    return keys, datas
+
+pass
+