buildz 0.9.10__tar.gz → 0.9.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.10
+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.10 → 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.10 → 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.10 → 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.10 → buildz-0.9.11}/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.11/buildz/log.py

@@ -0,0 +1,251 @@
+#
+
+
+from . import xf, ioc, fz, dz, path as pathx
+from .base import Base
+import time, sys, threading, os
+class Check(Base):
+    def str(self):
+        return f"Check<self.whitelist: {self.whitelist}, self.blacklist: {self.blacklist}, self.default_pass: {self.default_pass}>"
+    @staticmethod
+    def build_conf(conf):
+        whitelist, blacklist, default_pass, passes, rejects,default = dz.g(conf, whitelist=None, blacklist=None, default_pass=False, passes=[], rejects = [], default=False)
+        default_pass = default_pass or default
+        whitelist = whitelist or passes
+        blacklist = blacklist or rejects
+        return Check(whitelist, blacklist, default_pass)
+    def init(self, whitelist=[], blacklist=[], default_pass=False):
+        self.whitelist = set(whitelist)
+        self.blacklist = set(blacklist)
+        self.default_pass = default_pass
+    def add_pass(self, tag):
+        self.whitelist.add(tag)
+        if tag in self.blacklist:
+            self.blacklist.remove(tag)
+    def remove_pass(self, tag):
+        self.whitelist.remove(tag)
+    def add_reject(self, tag):
+        self.blacklist.add(tag)
+        if tag in self.whitelist:
+            self.whitelist.remove(tag)
+    def remove_reject(self, tag):
+        self.blacklist.remove(tag)
+    def set_default(self, val):
+        self.default_pass = val
+    def call(self, tag):
+        if tag in self.whitelist:
+            return True
+        if tag in self.blacklist:
+            return False
+        return self.default_pass
+class Log(Base):
+    '''
+        日志的基类或壳，需要传入实际输出方法或者实现do_log方法
+        提供方法接收参数生成日志格式字符串，然后调用实际输出方法或do_log
+    '''
+    def build_tags(self, conf):
+        tags,shows = dz.g(conf, tags=None, shows=None)
+        if tags is not None:
+            tags = Check.build_conf(tags)
+        if shows is not None:
+            shows = Check.build_conf(shows)
+        print(f"tags: {tags}")
+        print(f"shows: {shows}")
+        self.check_tags = tags or self.check_tags
+        self.shows = shows or self.shows
+        return self
+    def show(self, type, on=True):
+        if not on:
+            return self.unshow(type)
+        self.shows.add_pass(type)
+    def unshow(self, type):
+        self.shows.add_reject(type)
+    def call(self, _tag):
+        return self.tag(_tag)
+    def tag(self, _tag):
+        if _tag is not None and type(_tag) != str:
+            try:
+                if not hasattr(_tag, "__name__"):
+                    _tag = _tag.__class__
+                _tag = _tag.__module__+"."+_tag.__name__
+            except:
+                _tag = str(_tag)
+        base = self
+        if self.base is not None:
+            base = self.base
+        log = Log(self.shows, _tag, base)
+        return log
+    def get_tag(self):
+        return self._tag
+    def init(self, shows = None, tag= None, base = None, lock = False, check_tags=None):
+        self.shows=shows
+        self._tag = tag
+        self.base = base
+        self.check_tags = check_tags
+        if lock:
+            self.lock = threading.Lock()
+        else:
+            self.lock = None
+    def log(self, level, tag, *args):
+        if self.shows is not None and not self.shows(level):
+            return
+        if self.check_tags is not None and not self.check_tags(tag):
+            return
+        if self.lock is not None:
+            with self.lock:
+                return self.do_log(level, tag, *args)
+        return self.do_log(level, tag, *args)
+    def xlog(self, level, *args):
+        if not self.show(level):
+            return
+        self.log(level, self.tag, *args)
+    def do_log(self, level, tag, *args):
+        if self.base is not None:
+            return self.base.log(level, tag, *args)
+        raise Exception("unimpl")
+    def __getattr__(self, key):
+        def fc(*args):
+            self.log(key, self._tag, *args)
+        return fc
+    def clean(self):
+        pass
+    def done(self):
+        pass
+
+pass
+def replaces(s, *args):
+    for i in range(0,len(args),2):
+        k,v = args[i],args[i+1]
+        s = s.replace(k,v)
+    return s
+
+pass
+def mstr(s):
+    if s is None or len(s)==0:
+        return s
+    return s[:1].upper()+s[1:].lower()
+class FormatLog(Log):
+    def init(self, shows =None, tag=None, format=None, base=None, lock = False, check_tags=None):
+        if format is None:
+            format = "[{LEVEL}] %Y-%m-%d %H:%M:%S [{tag}] {msg}\n"
+        self.format=format
+        super().init(shows, tag, base, lock, check_tags)
+    def output(self, msg):
+        raise Exception("impl")
+    def do_log(self, level, tag, *args):
+        m_level = level.lower()
+        u_level = level.upper()
+        x_level = mstr(level)
+        args = [str(k) for k in args]
+        msg = " ".join(args)
+        if tag is None:
+            tag = "base"
+        rst = time.strftime(self.format, time.localtime(time.time()))
+        msg = replaces(rst, "{Level}", x_level, "{level}", m_level, "{LEVEL}", u_level, "{tag}", tag, "{msg}", msg)
+        self.output(msg)
+class FpLog(FormatLog):
+    @staticmethod
+    def build(conf,dp=None):
+        fp = dz.g(conf, fp=None)
+        dp = dz.g(conf, dp=dp)
+        if dp is not None:
+            if type(dp)==str:
+                dp = pathx.Path(dp)
+            fp = dp(fp)
+        reset = dz.g(conf, reset=False)
+        log = FpLog(fp)
+        if reset:
+            log.clean()
+        log.build_tags(conf)
+        return log
+    def init(self, fp = None,shows =None, tag=None, format=None, base=None, lock = False, check_tags=None):
+        super().init(shows, tag, format, base, lock, check_tags)
+        self.fp = fp
+    def clean(self):
+        fp = time.strftime(self.fp)
+        fz.removes(fp)
+    def output(self, msg):
+        if self.fp is not None:
+            fp = time.strftime(self.fp)
+            fz.makefdir(fp)
+            fz.write(msg.encode("utf-8"), fp, 'ab')
+
+pass
+class StdLog(FormatLog):
+    @staticmethod
+    def build(conf,*a,**b):
+        log = StdLog()
+        log.build_tags(conf)
+        return log
+    def output(self, msg):
+        sys.stdout.write(msg)
+
+pass
+class Logs(Log):
+    '''
+    {
+        type: logs
+    }
+    '''
+    @staticmethod
+    def build(conf, *a,**b):
+        conf_logs = dz.g(conf, logs=[])
+        if len(conf_logs) == 0:
+            return StdLog.build(conf)
+        logs = []
+        for conf_log in conf_logs:
+            logs.append(builds(conf_log))
+        log = Logs(logs)
+        log.build_tag(conf)
+        return log
+    def init(self, logs=[], shows = None, tag= None, lock = False, check_tags=None):
+        super().init(shows, tag, lock=lock, check_tags=check_tags)
+        self.logs = list(logs)
+    def do_log(self, level, tag, *args):
+        for _log in self.logs:
+            _log.log(level, tag, *args)
+    def done(self):
+        for log in self.logs:
+            log.done()
+    def clean(self):
+        for log in self.logs:
+            log.clean()
+
+pass
+class Builds(Base):
+    def init(self, default=None):
+        self.fcs = {}
+        self.default = default
+    def addx(self, **maps):
+        for k,v in maps.items():
+            self.fcs[k] = v
+    def add(self, key, fc):
+        self.fcs[key] = fc
+    def call(self, conf, type=None,*a,**b):
+        if type is None:
+            type = dz.g(conf, type=self.default)
+        return self.fcs[type](conf,*a,**b)
+
+pass
+builds = Builds("logs")
+builds.addx(file=FpLog.build)
+builds.addx(std=StdLog.build)
+builds.addx(logs=Logs.build)
+build_conf = builds
+
+def simple(fp=None,std=True, shows=None, tag=None, format=None,lock=False):
+    logs = []
+    if fp is not None:
+        logs.append(FpLog(fp,shows,tag,format,lock))
+    if std:
+        logs.append(StdLog(shows,tag,format,lock))
+    return Logs(logs)
+
+pass
+def build(obj=None, shows=None, tag=None, format=None):
+    if obj is None:
+        return StdLog(shows, tag, format)
+    return obj
+
+pass
+make=build

{buildz-0.9.10 → buildz-0.9.11}/buildz/tools.py

@@ -1,6 +1,6 @@
 #coding=utf-8
 # from buildz.tools import *
-from . import pyz,xf,fz,Base, ioc, logz,xz, pathz, cachez, argz, evalz,dz,confz, path as pathx,argx
+from . import pyz,xf,fz,Base, ioc, logz,xz, pathz, cachez, argz, evalz,dz,confz, path as pathx,argx, log as logx
 from .tz.time import timecost,showcost
 from .ioc import wrap
 from .base import fcBase

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.10
+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.10 → buildz-0.9.11}/buildz.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ buildz/base.py
 buildz/cmd.py
 buildz/confz.py
 buildz/dz.py
+buildz/log.py
 buildz/logz.py
 buildz/path.py
 buildz/pathz.py
@@ -20,6 +21,7 @@ buildz.egg-info/SOURCES.txt
 buildz.egg-info/dependency_links.txt
 buildz.egg-info/top_level.txt
 buildz/_dz/conf.py
+buildz/_dz/confx.py
 buildz/_dz/mapz.py
 buildz/_dz/oconf.py
 buildz/_dz/omapz.py

{buildz-0.9.10 → buildz-0.9.11}/setup.py

@@ -7,7 +7,7 @@ from setuptools import setup, find_packages
 
 setup(
     name = 'buildz',
-    version = '0.9.10',
+    version = '0.9.11',
     keywords='buildz',
     long_description=open('README.md', 'r', encoding="utf-8").read(),
     long_description_content_type='text/markdown',