buildz 0.3.9__tar.gz → 0.6.42__tar.gz

buildz-0.6.42/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: buildz
+Version: 0.6.42
+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
+Author-email: 1309458652@qq.com
+License: Apache License 2.0
+Keywords: buildz
+Platform: any
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# buildz
+声明:
+禁止将本项目代码用于ai训练
+declaration:
+Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+```
+1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
+2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下
+3，其他工具模块：
+    buildz.fz: 文件夹查找
+    buildz.pyz: 简化python __import__调用
+    buildz.argx: 按格式读命令行参数
+    buildz.tz: 加些工具，目前只有myerse diff字符串比较算法
+    buildz.demo: 使用参考，运行"python -m buildz"会用这个模块
+    buildz.db: sql集成工具，自用，里面import了其他sql库，使用运行"python -m buildz.db 配置文件路径"
+    buildz.base: 封装了一个基础类，继承它可以少写一些代码
+    buildz.html: xml（html）内容读取和解析
+    buildz.auto: 自动化操作（主要是做自动化测试方便些，如果不怕写一堆配置文件的话）
+代码关系:
+    buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz都是独立的模块
+    buildz.ioc需要buildz.xf和buildz.pyz
+    buildz.db需要buildz.xf
+    buildz.demo需要其他全部模块
+
+运行python -m buildz查看帮助
+
+持续更新中。。。
+2025/01/17:
+加了argz模块和evalz模块
+argz模块用于命令行参数匹配
+evalz模块用于可配置真假判断
+命令行还差一个入参转map的
+2024/12/22:
+增加pathz模块，方便处理路径，修改ioc和db
+2024/12/18:
+增加数据映射xz，数据库db增加类似orm功能以及表和索引结构查询功能（目前只写了mysql,oracle,sqlite3的查询），配置文件读写xf的输出增加对ListMap的支持(dumpx, dumpxf)
+2024/11/11:
+新增buildz.tz.xfind，对json做查询用的，功能类似jsonpath，自己实现的原因是好玩，以及不想为了用jsonpath去学对应的语法
+2024/10/08:
+增强auto配置功能，在auto增加数据库使用的封装，后续考虑出文档。。。如果有时间
+2024/09/25:
+修复bug，增强html的搜索功能，增强auto配置功能
+auto里加了个request的demo，里面用的requests库，可以直接配置来进行http调用
+2024/09/24:
+增加模块html:html页面解析
+增加模块auto:自动化调用
+
+2024/09/09
+ioc:
+    加修饰器
+    加配置refs
+
+PS: 对比了下json.loads（修改了下json的scanner.py，让它在纯python下运行，不然json.loads会更快）和目前的xf.loads(buildz.xf.readz.loads)的速度，xf.loads比json.loads慢7倍，可能是读字符串更频繁，方法调用更多（为了代码更结构化和容易修改），其实有一版更慢(buildz.xf.read.loads，废弃代码，后面看情况删掉)，慢100倍，因为只考虑结构化，没考虑列表增减开销（获得的经验教训是别直接用python的列表list当堆栈做append和pop，特别慢！）
+
+1, a profile file format base on json, make it easy to write profile file, module is in buildz.xf
+2, a ioc profile file read function base on xf format, module is in buildz.ioc
+3, other tools module:
+    buildz.fz: file search
+    buildz.pyz: make it easier to use python's __import__ function
+    buildz.argx: read command argument in special format
+    buildz.demo: example codes to use buildz, run "python -m buildz" will use this module
+code relationship:
+    buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz is independent
+    buildz.ioc use buildz.xf and buildz.pyz
+    buildz.tz: some tools, only contains "myerse diff algorithm" now
+    buildz.demo use all other modules
+
+run python -m buildz to see help
+
+continue updating...
+
+PS: testing speed on json.loads(has modified scanner.py in json module to make it purely run on Python, which make it run slower) and xf.loads(real func is buildz.xf.readz.loads), xf.loads takes 7 times longer than json.loads, it may cost by more func calls and more string cutting and reading(to make codes more structuring and easier to update)
+```

buildz-0.6.42/README.md

@@ -0,0 +1,73 @@
+# buildz
+声明:
+禁止将本项目代码用于ai训练
+declaration:
+Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+```
+1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
+2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下
+3，其他工具模块：
+    buildz.fz: 文件夹查找
+    buildz.pyz: 简化python __import__调用
+    buildz.argx: 按格式读命令行参数
+    buildz.tz: 加些工具，目前只有myerse diff字符串比较算法
+    buildz.demo: 使用参考，运行"python -m buildz"会用这个模块
+    buildz.db: sql集成工具，自用，里面import了其他sql库，使用运行"python -m buildz.db 配置文件路径"
+    buildz.base: 封装了一个基础类，继承它可以少写一些代码
+    buildz.html: xml（html）内容读取和解析
+    buildz.auto: 自动化操作（主要是做自动化测试方便些，如果不怕写一堆配置文件的话）
+代码关系:
+    buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz都是独立的模块
+    buildz.ioc需要buildz.xf和buildz.pyz
+    buildz.db需要buildz.xf
+    buildz.demo需要其他全部模块
+
+运行python -m buildz查看帮助
+
+持续更新中。。。
+2025/01/17:
+加了argz模块和evalz模块
+argz模块用于命令行参数匹配
+evalz模块用于可配置真假判断
+命令行还差一个入参转map的
+2024/12/22:
+增加pathz模块，方便处理路径，修改ioc和db
+2024/12/18:
+增加数据映射xz，数据库db增加类似orm功能以及表和索引结构查询功能（目前只写了mysql,oracle,sqlite3的查询），配置文件读写xf的输出增加对ListMap的支持(dumpx, dumpxf)
+2024/11/11:
+新增buildz.tz.xfind，对json做查询用的，功能类似jsonpath，自己实现的原因是好玩，以及不想为了用jsonpath去学对应的语法
+2024/10/08:
+增强auto配置功能，在auto增加数据库使用的封装，后续考虑出文档。。。如果有时间
+2024/09/25:
+修复bug，增强html的搜索功能，增强auto配置功能
+auto里加了个request的demo，里面用的requests库，可以直接配置来进行http调用
+2024/09/24:
+增加模块html:html页面解析
+增加模块auto:自动化调用
+
+2024/09/09
+ioc:
+    加修饰器
+    加配置refs
+
+PS: 对比了下json.loads（修改了下json的scanner.py，让它在纯python下运行，不然json.loads会更快）和目前的xf.loads(buildz.xf.readz.loads)的速度，xf.loads比json.loads慢7倍，可能是读字符串更频繁，方法调用更多（为了代码更结构化和容易修改），其实有一版更慢(buildz.xf.read.loads，废弃代码，后面看情况删掉)，慢100倍，因为只考虑结构化，没考虑列表增减开销（获得的经验教训是别直接用python的列表list当堆栈做append和pop，特别慢！）
+
+1, a profile file format base on json, make it easy to write profile file, module is in buildz.xf
+2, a ioc profile file read function base on xf format, module is in buildz.ioc
+3, other tools module:
+    buildz.fz: file search
+    buildz.pyz: make it easier to use python's __import__ function
+    buildz.argx: read command argument in special format
+    buildz.demo: example codes to use buildz, run "python -m buildz" will use this module
+code relationship:
+    buildz.xf, buildz.pyz, buildz.argx, buildz.fz, buildz.tz is independent
+    buildz.ioc use buildz.xf and buildz.pyz
+    buildz.tz: some tools, only contains "myerse diff algorithm" now
+    buildz.demo use all other modules
+
+run python -m buildz to see help
+
+continue updating...
+
+PS: testing speed on json.loads(has modified scanner.py in json module to make it purely run on Python, which make it run slower) and xf.loads(real func is buildz.xf.readz.loads), xf.loads takes 7 times longer than json.loads, it may cost by more func calls and more string cutting and reading(to make codes more structuring and easier to update)
+```

buildz-0.6.42/buildz/__init__.py

@@ -0,0 +1,9 @@
+#coding=utf-8
+
+__version__="0.6.34"
+
+# 小号多
+__author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
+
+from .argx import fetch as args
+from .base import Base, WBase

buildz-0.6.42/buildz/__main__.py

@@ -0,0 +1,6 @@
+#coding=utf-8
+from .demo.test import test
+if __name__=="__main__":
+    test()
+
+pass

buildz-0.6.42/buildz/argx.py

@@ -0,0 +1,127 @@
+#coding=utf-8
+import sys
+class Fetch:
+    """
+    命令行参数读取
+    ft = Fetch("id,name,kind".split(","), {"a":"age"})
+        or
+    ft = Fetch(*xf.loads("[[id,name,kind],{a:age}]"))
+
+    ft("001 zero life -a12".split(" ")) = {'id': '001', 'name': 'zero', 'kind': 'life', 'age': '12'}
+
+    但更简单的方法是:
+    xf.args("{id:'001', name: zero, kind: life, age: 12}".split(" ")) = {'id': '001', 'name': 'zero', 'kind': 'life', 'age': 12}
+    python buildz.xf {id:'001', name: zero, kind: life, age: 12}
+    就是对引号不太适用
+    """
+    def __init__(self, args = [], maps ={}):
+        args = [maps[k] if k in maps else k for k in args]
+        self.args = args
+        self.maps = maps
+    def des(self):
+        cmd = " ".join(self.args)
+        adds = []
+        for k, val in self.maps.items():
+            tmp = f"    [-{k} param] [--{val}=param]"
+            adds.append(tmp)
+        adds = [cmd]+adds
+        rs = "\n".join(adds)
+        return rs
+    def check(self, args, ks):
+        rst = []
+        for k in ks:
+            if k not in args:
+                rst.append(k)
+        return rst
+    def __call__(self, argv = None):
+        args, maps = fetch(argv)
+        rst = {}
+        for i in range(len(args)):
+            if i >= len(self.args):
+                break
+            key = self.args[i]
+            rst[key] = args[i]
+        for key in maps:
+            rst[key] = maps[key]
+        for key in self.maps:
+            rkey = self.maps[key]
+            if key in rst:
+                val = rst[key]
+                rst[rkey] = val
+                del rst[key]
+        return rst
+
+pass
+class FetchX(Fetch):
+    def __init__(self, *a, **b):
+        super().__init__(a,b)
+
+pass
+def fetch(argv = None):
+    r"""
+    format: a b c -a 123 -b456 --c=789 +d  -x"??? ???" y z
+    return: [a,b,c,y,z], {a:123,b:456,c:789,d:1,x:'??? ???'}
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+    lists, maps = [],{}
+    argv = [str(k).strip() for k in argv]
+    argv = [k for k in argv if k!=""]
+    i = 0
+    while i<len(argv):
+        v = argv[i]
+        make_plus = 0
+        if v in ["-", "--", "+"]or v[0] not in "+-":
+            lists.append(v)
+            i+=1
+            continue
+        if v[0] == "+":
+            key = v[1:]
+            make_plus = 1
+            val = 1
+        else:
+            if v[1]=="-":
+                kv = v[2:]
+                x = kv.split("=")
+                key = x[0]
+                val = "=".join(x[1:])
+                if len(val)==0:
+                    val = 1
+            else:
+                key = v[1]
+                if len(v)>2:
+                    val = v[2:]
+                else:
+                    if i+1>=len(argv):
+                        val = 1
+                    else:
+                        val = argv[i+1]
+                        i+=1
+        if make_plus:
+            keys = key.split(",")
+        else:
+            keys = [key]
+        for key in keys:
+            if key not in maps:
+                maps[key] = []
+            maps[key].append(val)
+        i+=1
+    for k in maps:
+        v = maps[k]
+        if len(v)==1:
+            maps[k] = v[0]
+    return lists, maps
+
+pass
+
+def get(maps, keys, default=None):
+    if type(keys) not in [list, tuple]:
+        keys = [keys]
+    for key in keys:
+        if key in maps:
+            return maps[key]
+    return default
+
+pass
+        
+

buildz-0.6.42/buildz/argz/__init__.py

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

buildz-0.6.42/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.42/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.42/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)