buildz 0.6.41__tar.gz → 0.6.43__tar.gz

{buildz-0.6.41/buildz.egg-info → buildz-0.6.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.6.41
+Version: 0.6.43
 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
@@ -38,6 +38,13 @@ Codes of this project are not allowed to be used for AI training or any other fo
 运行python -m buildz查看帮助
 
 持续更新中。。。
+2025/01/21:
+修改xf的读写，读加上报错字符串位置，写改成递归调用减少时间开销
+2025/01/17:
+加了argz模块和evalz模块
+argz模块用于命令行参数匹配
+evalz模块用于可配置真假判断
+命令行还差一个入参转map的
 2024/12/22:
 增加pathz模块，方便处理路径，修改ioc和db
 2024/12/18:

{buildz-0.6.41 → buildz-0.6.43}/README.md

@@ -25,6 +25,13 @@ Codes of this project are not allowed to be used for AI training or any other fo
 运行python -m buildz查看帮助
 
 持续更新中。。。
+2025/01/21:
+修改xf的读写，读加上报错字符串位置，写改成递归调用减少时间开销
+2025/01/17:
+加了argz模块和evalz模块
+argz模块用于命令行参数匹配
+evalz模块用于可配置真假判断
+命令行还差一个入参转map的
 2024/12/22:
 增加pathz模块，方便处理路径，修改ioc和db
 2024/12/18:

buildz-0.6.43/buildz/argz/__init__.py

@@ -0,0 +1,3 @@
+from .argz import *
+from .callz import *
+from .evalx import *

buildz-0.6.43/buildz/argz/argz.py

@@ -0,0 +1,223 @@
+from buildz import Base, xf
+from . import build
+class ArgExp(Exception):
+    def __repr__(self):
+        return self.__str__()
+    def __str__(self):
+        return f"stype: {self.stype}, trs: {self.trs}, des: {self.des}"
+    def __init__(self, stype, trs, des=None, prev = None):
+        super().__init__()
+        self.prev = prev
+        self.stype = stype
+        self.trs = trs
+        self.des = des
+
+pass
+class Args(Base):
+    def call(self, args, maps):
+        return args, maps
+    def deal_exp(self, exp):
+        return exp
+
+pass
+class ArrArgs(Args):
+    def init(self, args = None):
+        if args is None:
+            args = []
+        self.args = args
+    def add(self, item):
+        self.args.append(item)
+        return self
+    def call(self, args, maps):
+        i=0
+        try:
+            for i in range(len(self.args)):
+                item = self.args[i]
+                args, maps = item(args,maps)
+        except ArgExp as exp:
+            for j in range(i-1, -1, -1):
+                exp = self.args[j].deal_exp(exp)
+            raise exp
+        return args, maps
+    def deal_exp(self, exp):
+        for i in range(len(self.args)-1, -1, -1):
+            exp = self.args[i].deal_exp(exp)
+        return exp
+class RangeListArgs(Args):
+    def init(self, min = 0, max = None):
+        self.min = min
+        self.max = max
+    def deal_exp(self, exp):
+        trs = set()
+        for key, vtype in exp.trs:
+            if vtype=='list':
+                trs.add((key+self.min, vtype))
+            else:
+                trs.add((key, vtype))
+        #exp.trs = trs
+        return ArgExp(exp.stype, trs, exp.des, exp)
+    def call(self, args, maps):
+        if len(args)<self.min:
+            raise ArgExp("need", set([(self.min, 'list')]))
+        if self.max is None:
+            args = args[self.min:]
+        else:
+            args = args[self.min:self.max]
+        return args, maps
+class RangeListBuild(build.Build):
+    def call(self, conf):
+        rg = xf.g(conf, range=None)
+        if rg is None:
+            return None
+        if type(rg)==int:
+            rg = [rg, None]
+        return RangeListArgs(*rg)
+class ArgItem(Base):
+    # vtype = 'dict' | 'list'
+    def init(self, key, vtype="dict", need = False, default = False, value = None, des = None,remove=True):
+        self.vtype = vtype
+        self.key = key
+        self.need = need
+        self.default = default
+        self.value = value
+        self.trs = []
+        self.remove = remove
+        if des is None:
+            des = key
+        self.des = des
+    def add(self, key, vtype="dict"):
+        self.trs.append((key, vtype))
+        return self
+    def deal_exp(self, exp):
+        trs = set()
+        for key, vtype in exp.trs:
+            if key == self.key and vtype==self.vtype:
+                trs.update(self.trs)
+            else:
+                trs.add((key, vtype))
+        #exp.trs = trs
+        return ArgExp(exp.stype, trs, exp.des, exp)
+        return exp
+    def call(self, set_args, args, maps, rst_args, rst_maps):
+        val = None
+        find = False
+        for key, vtype in self.trs:
+            if vtype =="dict":
+                if key in maps:
+                    val = maps[key]
+                    if self.remove:
+                        del maps[key]
+                    find = True
+                    break
+            else:
+                if key in set_args:
+                    val = args[key]
+                    if self.remove:
+                        set_args.remove(key)
+                    find = True
+                    break
+        if not find:
+            if self.default:
+                find = True
+                val = self.value
+        if not find and self.need:
+            raise ArgExp("need", set(self.trs), self.des)
+        if self.vtype == 'dict':
+            rst_maps[self.key] = val
+        else:
+            rst_args[self.key] = val
+
+pass
+class ArgItemBuild(build.Build):
+    def call(self, key, vtype, conf):
+        need = xf.g(conf, need=False)
+        default = xf.g(conf, default=False)
+        value = xf.g(conf, value=None)
+        des = xf.g(conf, des=None)
+        remove = xf.g(conf, remove=True)
+        src = conf['src']
+        if type(src) not in (list, tuple):
+            src = [src]
+        item = ArgItem(key, vtype, need, default, value, des, remove)
+        for s in src:
+            if type(s) not in (list, tuple):
+                if type(s)==int:
+                    s = [s, 'list']
+                else:
+                    s = [s, 'dict']
+            if s[1] in ('l', 'args'):
+                s[1] = 'list'
+            elif s[1] in ('d', 'maps'):
+                s[1] = 'dict'
+            item.add(*s)
+        return item
+class TrsArgs(Args):
+    def deal_exp(self, exp):
+        for item in self.args:
+            exp = item.deal_exp(exp)
+        return exp
+    def init(self, args=None, keep = True):
+        super().init()
+        if args is None:
+            args = []
+        self.args = args
+        self.keep = keep
+    def add(self, item):
+        self.args.append(item)
+        return self
+    def call(self, args, maps):
+        rst_args, rst_maps = {}, {}
+        set_args = set(range(len(args)))
+        for item in self.args:
+            item(set_args, args, maps, rst_args, rst_maps)
+        l_args = 0
+        if len(rst_args)>0:
+            l_args= max(rst_args.keys())
+        out_args = []
+        if self.keep and len(set_args)>0:
+            for i in range(max(set_args)):
+                if i in set_args:
+                    out_args.append(args[i])
+        for i in range(l_args+1):
+            if i in rst_args:
+                if len(out_args)<i:
+                    raise ArgExp("need", set([(i, 'list')]))
+                out_args.append(rst_args[i])
+        if self.keep:
+            for k in maps:
+                if k not in rst_maps:
+                    rst_maps[k] = maps[k]
+        return out_args, rst_maps
+
+pass
+class TrsArgsBuild(build.Build):
+    def init(self):
+        self.item = ArgItemBuild()
+        super().init(self.item)
+    def call(self, conf):
+        keep = xf.g(conf, keep = False)
+        lst = xf.g1(conf, list={}, args={})
+        dct = xf.g1(conf, dict={}, maps={})
+        items = []
+        for k, val in lst.items():
+            items.append(self.item(k, 'list', val))
+        for k, val in dct.items():
+            items.append(self.item(k, 'dict', val))
+        if len(items)==0:
+            return None
+        return TrsArgs(items, keep)
+class ArrArgsBuild(build.Build):
+    def init(self):
+        self.range = RangeListBuild()
+        self.trs = TrsArgsBuild()
+        super().init(self.trs, self.range)
+    def call(self, conf):
+        rg = self.range(conf)
+        trs = self.trs(conf)
+        if rg is None and trs is None:
+            return None
+        arr = [rg, trs]
+        arr = [k for k in arr if k is not None]
+        if len(arr)==1:
+            return arr[0]
+        return ArrArgs(arr)

buildz-0.6.43/buildz/argz/build.py

@@ -0,0 +1,48 @@
+#
+from buildz import Base, xf
+class Build(Base):
+    def init(self, *binds):
+        self.builder = None
+        self.binds = binds
+    def bind(self, builder):
+        self.builder = builder
+        for obj in self.binds:
+            obj.bind(builder)
+    def call(self, conf):
+        assert 0, 'not impl'
+class Builder(Base):
+    def init(self, fc = None, key_id = "id"):
+        self.vars = {}
+        self.confs = {}
+        self.key_id = key_id
+        self.set_fc(fc)
+    def set_fc(self, fc):
+        fc.bind(self)
+        self.fc = fc
+        return self
+    def var(self, key, obj):
+        self.vars[key] = obj
+        return self
+    def get_var(self, key):
+        return self.vars[key]
+    def get_conf(self, key):
+        if type(key) == dict:
+            conf = key
+        else:
+            if key not in self.confs:
+                return self.get_var(key)
+            conf = self.confs[key]
+        return self.fc(conf)
+    def conf(self, data):
+        if type(data) in (list, tuple):
+            rst = {}
+            for it in data:
+                if self.key_id not in it:
+                    continue
+                id = it[self.key_id]
+                rst[id] = it
+            data = rst
+        self.confs = data
+        return self
+    def call(self, data, key="main"):
+        return self.conf(data).get_conf(key)

buildz-0.6.43/buildz/argz/callz.py

@@ -0,0 +1,115 @@
+from buildz import Base, xf
+from . import argz
+from . import build
+from . import evalx
+class Fc(Base):
+    def str(self):
+        return str(self.fc)
+    def init(self, fc=None):
+        self.fc = fc
+    def call(self, args, maps):
+        return self.fc(*args, **maps)
+    @staticmethod
+    def make(fc):
+        if isinstance(fc, Fc):
+            return fc
+        return Fc(fc)
+class ArgsCall(Fc):
+    def init(self, fc, args=None, name = None):
+        fc=self.make(fc)
+        if name is None:
+            name = str(fc)
+        self.name = name
+        self.fc = fc
+        self.args = args
+    def call(self, args, maps):
+        if self.args is not None:
+            args, maps = self.args(args, maps)
+        try:
+            return self.fc(args, maps)
+        except argz.ArgExp as exp:
+            if self.args is not None:
+                exp = self.args.deal_exp(exp)
+            raise exp
+class Calls(Fc):
+    def str(self):
+        return "argz.Calls"
+    def init(self, fcs = None, args=None, name = None):
+        if name is None:
+            name = "argz.calls"
+        self.name = name
+        if fcs is None:
+            fcs = []
+        self.fcs = fcs
+        self.args = args
+    def add(self, fc):
+        fc=self.make(fc)
+        self.fcs.append(fc)
+    def call(self, args, maps):
+        val = None
+        if self.args is not None:
+            args, maps = self.args(args, maps)
+        try:
+            for fc in self.fcs:
+                val = fc(args, maps)
+            return val
+        except argz.ArgExp as exp:
+            if self.args is not None:
+                exp = self.args.deal_exp(exp)
+            raise exp
+class EvalCall(Fc):
+    def init(self, fc, eval=None, name = None):
+        fc=self.make(fc)
+        if name is None:
+            name = str(fc)
+        self.eval = eval
+        self.fc = fc
+        self.name = name
+    def call(self, args, maps):
+        if self.eval is not None:
+            if not self.eval([args, maps]):
+                return None
+        return self.fc(args, maps)
+class CallsBuild(build.Build):
+    def call(self, conf):
+        ctype = xf.g(conf, type=None)
+        if ctype != "calls":
+            return None
+        calls = xf.g(conf, calls = [])
+        if len(calls)==0:
+            return None
+        calls = [self.builder.get_conf(conf) for conf in calls]
+        return Calls(calls)
+class FcBuild(build.Build):
+    def call(self, conf):
+        ctype = xf.g(conf, type=None)
+        if ctype != "call":
+            return None
+        src = xf.g(conf, src = None)
+        fc = self.builder.get_var(src)
+        return Fc(fc)
+class CallBuild(build.Build):
+    def init(self):
+        self.args = argz.ArrArgsBuild()
+        self.eval = evalx.EvalBuild()
+        self.fc = FcBuild()
+        self.calls = CallsBuild()
+        super().init(self.args, self.eval, self.fc, self.calls)
+    def call(self, conf):
+        args = self.args(conf)
+        judges = self.eval(conf)
+        fc = self.fc(conf)
+        calls = self.calls(conf)
+        bfc = fc is None
+        bcls = calls is None
+        assert (bfc+bcls)==1
+        if fc is None:
+            fc = calls
+        if args is not None:
+            fc = ArgsCall(fc, args)
+        if judges is not None:
+            fc = EvalCall(fc, judges)
+        return fc
+class CallBuilder(build.Builder):
+    def init(self, key_id = "id"):
+        super().init(CallBuild(), key_id)

buildz-0.6.43/buildz/argz/evalx.py

@@ -0,0 +1,30 @@
+#
+from buildz import evalz,xf
+
+from . import build
+class VarEval(evalz.Eval):
+    def init(self, key, stype = 'list'):
+        self.key = key
+        self.stype = stype
+    def call(self, obj):
+        args, maps = obj
+        if self.stype=='list':
+            return args[self.key]
+        return maps[self.key]
+class VarBuild(evalz.Build):
+    def init(self, stype="list"):
+        super().init()
+        self.stype = stype
+    def call(self, data):
+        return VarEval(data['data'][0], self.stype)
+lb = VarBuild('list')
+db = VarBuild('dict')
+evalBuilder = evalz.EvalBuilder.Make().set(["l","list","args"], lb).set(['d','dict','maps'], db)
+class EvalBuild(build.Build):
+    def call(self, conf):
+        judge = xf.g1(conf, judge=None, eval=None)
+        if judge is None:
+            return None
+        return evalBuilder(judge)
+
+pass

buildz-0.6.43/buildz/argz/test.py

@@ -0,0 +1,26 @@
+from buildz import argz,xf,Base,evalz,pathz
+import sys,os
+
+path = pathz.Path()
+path.set("res", path(path.dir(__file__), "tests"))
+conf = xf.loadf(path.res("conf.js"))
+
+def search(dp, filepath = None, content = None):
+    print(f"call in search: ({dp}, {filepath}, {content})")
+    return f"call in search {dp}"
+
+pass
+
+
+mg = argz.CallBuilder().var("search", search)
+fc = mg(conf)
+
+ins = xf.args(base=0)
+args, maps = ins.args, ins.maps
+
+rst = fc(args, maps)
+print(f"rst: {rst}")
+'''
+python -m buildz.argz.test search /d/rootz
+python -m buildz.argz.test search /d/rootz f=asf c=test
+'''

buildz-0.6.43/buildz/argz/test_obj.py

@@ -0,0 +1,38 @@
+from buildz import argz,xf,Base,evalz,pathz
+'''
+python -m buildz.argz.test search /d/rootz
+python -m buildz.argz.test_obj search /d/rootz f=asf c=test
+'''
+
+def search(dp, filepath = None, content = None):
+    print(f"call in search: ({dp}, {filepath}, {content})")
+    return f"call in search {dp}"
+
+pass
+
+args = argz.ArrArgs().add(
+    argz.RangeListArgs(1)
+)
+trs = argz.TrsArgs().add(
+    argz.ArgItem("filepath", "dict").add("f", "dict").add("fp", "dict").add("filepath", "dict")
+).add(
+    argz.ArgItem(0, "list",need=True,des="path").add(0, "list")
+).add(
+    argz.ArgItem("content", "dict").add("c", "dict").add("ct", "dict").add("content", "dict")
+)
+args.add(trs)
+fc = argz.ArgsCall(search, args)
+judge = lambda obj:obj[0][0]=='search'
+fc = argz.EvalCall(fc, judge)
+fcs = argz.Calls([fc])
+
+
+
+main_args = argz.ArrArgs().add(argz.RangeListArgs(1))
+main = argz.ArgsCall(fcs, main_args)
+
+
+ins = xf.args(base=0)
+args, maps = ins.args, ins.maps
+rst = main(args, maps)
+print(rst)

buildz-0.6.43/buildz/argz/tests/conf.js

@@ -0,0 +1,31 @@
+{
+    id: main
+    type: calls
+    range: 1
+    calls: [
+        search
+    ]
+}
+{
+    id: search
+    type: call
+    src: search
+    judge: ['=', args[0], search]
+    range: 1
+    keep: 1
+    list: {
+        0: {
+            des: path
+            need: 1
+            src: 0
+        }
+    }
+    maps: {
+        filepath: {
+            src: [f, fp, filepath]
+        }
+        content: {
+            src: [c, ct, content]
+        }
+    }
+}

{buildz-0.6.41 → buildz-0.6.43}/buildz/db/dv/clickhousez.py

@@ -10,6 +10,9 @@ from .basez import SimpleDv, fetch
 from .structz import CMD
 class Db(SimpleDv):
     # func to impl:
+    def query(self, sql, vals={}, as_map = None):
+        assert len(vals)==0
+        return super().query(sql, {}, as_map)
     def to_list(self, rst):
         rows = self.cursor.description
         keys = [k[0].lower() for k in rows]

buildz-0.6.43/buildz/evalz/__init__.py

@@ -0,0 +1,2 @@
+
+from .evalz import *