buildz 0.7.1__tar.gz → 0.7.3__tar.gz

{buildz-0.7.1/buildz.egg-info → buildz-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.7.1
+Version: 0.7.3
 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
@@ -16,6 +16,13 @@ License-File: LICENSE
 禁止将本项目代码用于ai训练
 declaration:
 Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+
+邮箱1:1174534295@qq.com
+
+邮箱2:1309458652@qq.com
+
 ```
 1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下

{buildz-0.7.1 → buildz-0.7.3}/README.md

@@ -3,6 +3,13 @@
 禁止将本项目代码用于ai训练
 declaration:
 Codes of this project are not allowed to be used for AI training or any other form of machine learning processes.
+
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+
+邮箱1:1174534295@qq.com
+
+邮箱2:1309458652@qq.com
+
 ```
 1，在json格式基础上加了点东西，让配置文件写起来更简单，模块在buildz.xf下
 2，基于xf格式写了个ioc控制反转配置文件读取的程序，模块在buildz.ioc下

buildz-0.7.3/buildz/__init__.py

@@ -0,0 +1,25 @@
+#coding=utf-8
+
+__version__="0.7.2"
+
+# 小号多
+__author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
+__doc__ = '''
+使用此代码库发现bug或者有需求需要开发都可联系(QQ或邮箱联系，QQ就是邮箱号)
+buildz.xf: 简化的json
+buildz.xz: 简化对dict和list的读写
+buildz.ioc, buildz.iocz: ioc注入
+buildz.netz: 网络相关，包括ssl证书生成，正反向代理，端口映射，抓包
+buildz.db: SQL脚本处理工具，基于其他SQL处理库做了使用简化
+buildz.html: html文本处理
+buildz.gpuz: 机器学习用内存做显存的模型缓存，目前只写了基于pytorch的工具，测试卷积和注意力的效果还行
+buildz.fz: 文件处理
+buildz.auto: 自动化测试
+buildz.logz: 简单的日志工具
+buildz.pyz: 简化python系统相关调用
+buildz.base: 简化python类代码编写
+buildz.pathz: 简化文件路径相关的代码编写 
+'''
+
+from .argx import fetch as args
+from .base import Base, WBase,Args

{buildz-0.7.1 → buildz-0.7.3}/buildz/base.py

@@ -81,3 +81,32 @@ class With(Base):
         return cls
 
 pass
+
+class Args(Base):
+    def size(self):
+        return len(self.args)+len(self.maps)
+    def str(self):
+        return f"<Args args={self.args}, maps={self.maps}>"
+    @property
+    def lists(self):
+        return self.args
+    @lists.setter
+    def lists(self, val):
+        self.args=val
+    @lists.deleter
+    def lists(self):
+        del self.args
+    @property
+    def dicts(self):
+        return self.maps
+    @dicts.setter
+    def dicts(self, val):
+        self.maps=val
+    @dicts.deleter
+    def dicts(self):
+        del self.maps
+    def init(self, args, maps):
+        self.args = args
+        self.maps = maps
+
+pass

{buildz-0.7.1 → buildz-0.7.3}/buildz/gpuz/test/report.txt

@@ -1,6 +1,6 @@
 
 测试结果: 
-结论是：大概能达到纯显卡（75W，更高的没测）二分之一或三分之一的性能，显存不够的可以用用，主要是卷积层，卷积层cpu计算耗时很大，并且神经网络参数相对较少，线性层感觉cpu和显卡本来就差不太多
+训练模式大概能达到纯显卡（75W，更高的没测）二分之一或三分之一的性能，显存不够的可以用用
 
 环境: 
     笔记本（游戏本）
@@ -78,6 +78,7 @@ Analyze
     mean time cost using CPU: 16.668074309825897 sec
 显存扣掉3GB
 python -m buildz.gpuz.test.take_gpu_mem 12
+python -m buildz.gpuz.test.test_resnet_demo train cuda,cache,cpu
 No Used DictCache
  train: 0 mean loss: 7.049219369888306 time: 32.67351007461548
  train: 1 mean loss: 6.776383876800537 time: 26.468174934387207
@@ -99,8 +100,8 @@ Analyze
     mean time cost using CPU: 6.312976717948914 sec
 
 
-如果是注意力、卷积和线性层混合模型，测试模式，并且显卡不够，建议注意力和卷积全放显存，线性层全放内存，线性层显卡和CPU差距不大
+如果是测试模式，显存不够的时候，可以部分模型全放显存，部分全放内存，建议是卷积和注意力多放显存，线性层多放内存，因为线性层占用空间大
 convs = [...]
 linears = [...]
-cache = DictCache(dvs_nets = [convs, linears])
+cache = DictCache(dvs=[torch.device('cuda'), torch.device('cpu')], dvs_nets = [convs, linears])
 ...

{buildz-0.7.1 → buildz-0.7.3}/buildz/gpuz/torch/dict_middle.py

@@ -16,9 +16,14 @@ pass
 class DictCache(Base):
     '''
         用处：显存不够的时候，可以用本代码框架，代码会在forward和backward的时候自动把nets列表里需要计算的模型放入显存，不需要计算的放到内存，需要进行卷积训练的时候用处比较大（卷积计算显卡比CPU强太多）
-        使用本框架需要传入手动拆分成多个小模型的模型列表nets
+        暂不支持多显卡，因为开发者的电脑没有多显卡
+        DictCache实际提供两个功能：
+            1，缓存功能：模型需要使用的时候放显存，不需要的时候放内存
+            2，部分模型全放显存，部分模型全放内存，DictCache内部做传入数据的显存和内存的转换
+            两个功能可以同时使用，即部分模型用的时候放显存，不用的时候放内存，部分模型全放显存，部分模型全放内存
+        使用本框架需要使用者手动把模型拆成多个小模型，把小模型列表nets传入DictCache
         训练时大概有纯显卡二分之一到三分之一的性能，起码比CPU好，尤其是进行卷积计算，比cpu好太多
-        训练完使用时的线性层则比CPU还慢，但卷积还是比CPU好，所以非训练情况下，线性层最好都放gpu或cpu
+        训练完使用时的线性层则比CPU还慢，感觉没必要用，不过DictCache也提供了部分模型全放显存，部分模型全放内存的功能，显存不够的时候可以使用
         DictCache里的Dict意思是传入的模型列表nets会存字典里，Cache就是用内存作为显存的缓存
         代码实现原理是利用pytorch的几个勾子函数：
             model.register_forward_pre_hook会在模型forward之前调用
@@ -29,6 +34,7 @@ class DictCache(Base):
                 hook_unpack是在反向梯度计算的时候取回forward存储的tensor
         代码例子:
         code in buildz.gpuz.test.demo:
+
             from buildz.gpuz.torch import DictCache
             import torch
             from torch import nn,optim
@@ -69,6 +75,7 @@ class DictCache(Base):
                 torch.nn.utils.clip_grad_norm_(net.parameters(), max_norm=1.0)
                 opt.step()
             cache = DictCache([torch.device('cuda'), torch.device('cpu')],models,opts,3,opt_step, [cuda_models,cpu_models])
+
             # 训练:
             [md.train() for md in models]
             for inputs,targets in dataloader:
@@ -84,6 +91,7 @@ class DictCache(Base):
             with torch.no_grad():
                 outputs = cache.do_forward(lambda:real_model(inputs))
             print(outputs)
+            
             # 对比不用DictCache的时候
             # 注意：模型放入DictCache之后会挂上勾子函数，不再用DictCache的时要先调用DictCache的remove方法
             cache.remove()
@@ -100,7 +108,6 @@ class DictCache(Base):
                 torch.nn.utils.clip_grad_norm_(real_model.parameters(), max_norm=1.0)
                 full_opt.step()
                 print(loss.item())
-
             # 测试:
             inputs = torch.rand(1, dims).cuda()
             with torch.no_grad():

buildz-0.7.3/buildz/gpuz/torch/multi_dict_middle.py

@@ -0,0 +1,191 @@
+#
+import torch
+from torch import nn
+import threading as th
+from ... import Base
+import numpy as np
+'''
+注：
+没写好，还不能用
+'''
+class MultiDictCache(Base):
+    def init(self, nets, win_sizes=None, backward_deal=None, fc_inputs_to=None, default_dv = None, default_win_size=1):
+        '''
+            nets: [
+                net
+                (net, run_dv)
+                (net, run_dv, opt)
+                (net, (run_dv, cache_dv), opt)
+            ]
+            win_sizes: {
+                run_dv: size
+            }
+        '''
+        if default_dv is None:
+            default_dv = torch.device("cpu")
+        if fc_inputs_to is None:
+            fc_inputs_to = self.inputs_to
+        self.fc_inputs_to = fc_inputs_to
+        self.default_dv = default_dv
+        if win_sizes is None:
+            win_sizes = {}
+        self.default_win_size = default_win_size
+        self.win_sizes = win_sizes
+        #run_dvs = {}
+        rst = {}
+        nears = {}
+        for it in nets:
+            if type(it) not in (list,tuple):
+                it = [it]
+            if len(it)==1:
+                it.append(default_dv)
+            x = it[1]
+            if type(x) not in (list,tuple):
+                it[1] = [it[1]]
+            run_dvs.add(it[1][0])
+            net = it[0]
+            net_id = id(net0)
+            rst[net_id] = it
+            run_dv = it[1][0]
+            if run_dv not in nears:
+                nears[run_dv] = {}
+            nears[run_dv][net_id] = [-1,-1]
+            run_dvs[run_dv] = it
+        nets = rst
+        self.nets = nets
+        self.nears = nears
+        if type(dvs) not in (list,tuple):
+            dvs = [dvs]
+        self.gdv = dvs[0]
+        self.cdv = dvs[-1]
+        self.dvs = dvs
+        if dvs_nets is None:
+            dvs_nets = [[]]
+        if type(dvs_nets) not in (list, tuple):
+            dvs_nets = [dvs_nets]
+        dvs_nets = [k if k is not None else [] for k in dvs_nets]
+        ids_nocache = set()
+        fcs = []
+        for i in range(len(dvs_nets)):
+            for net in dvs_nets[i]:
+                fc = net.register_forward_pre_hook(self.hook_forward_pre_tensor(i))
+                fcs.append(fc)
+                ids_nocache.add(id(net))
+        self.ids_nocache = ids_nocache
+        self.dvs_nets = dvs_nets
+        fcs += [net.register_forward_pre_hook(self.hook_forward_pre) for net in nets if id(net) not in ids_nocache]
+        fcs+=[net.register_forward_hook(self.hook_forward) for net in nets if id(net) not in ids_nocache]
+        net = nets[0]
+        if hasattr(net, "register_full_backward_hook"):
+            fcs+=[net.register_full_backward_hook(self.hook_backward) for net in nets]
+        else:
+            fcs+=[net.register_backward_hook(self.hook_backward) for net in nets]
+        self.src_nets = nets
+        self.fcs = fcs
+        self.nets = {id(net):net for net in nets}
+        self.ctxs = {id(net):[] for net in nets}
+        if opts is not None:
+            opts = {id(net): opt for net,opt in zip(nets, opts)}
+        self.opts = opts
+        self.pools = []
+        self.win_size = win_size
+        self.backward_deal = backward_deal
+        self.nears = {id(net):[-1,-1] for net in nets}
+        self.curr = -1
+        self.done_backward = -1
+        self.no_caches = True
+    def remove(self):
+        [fc.remove() for fc in self.fcs]
+    def hook_forward_pre_tensor(self, i):
+        def hook(model, ins):
+            model.to(self.dvs[i])
+            ins = self.fc_inputs_to(ins, self.dvs[i])
+            return ins
+        return hook
+    @staticmethod
+    def inputs_to(inputs, dv):
+        if isinstance(inputs, torch.Tensor):
+            return inputs.to(dv)
+        inputs = tuple([k.to(dv) for k in inputs])
+        return inputs
+    def ctxs_to(self, i, dv):
+        if dv is None:
+            self.ctxs[i] = []
+        else:
+            self.ctxs[i] = [k.to(dv) for k in self.ctxs[i]]
+    def copy_backward(self, nid):
+        for c_id in self.pools:
+            self.nets[c_id].to(self.cdv)
+            self.ctxs_to(c_id, None)
+        self.pools = []
+        self.nets[nid].to(self.gdv)
+        self.ctxs_to(nid, self.gdv)
+        self.pools.append(nid)
+        next_id = nid
+        for i in range(self.win_size-1):
+            next_id = self.nears[next_id][1]
+            if next_id<0:
+                break
+            self.nets[next_id].to(self.gdv)
+            self.ctxs_to(next_id, self.gdv)
+            self.pools.append(next_id)
+    def copy_forward(self, nid, model):
+        for c_id in self.pools:
+            self.nets[c_id].to(self.cdv)
+            self.ctxs_to(c_id, self.cdv)
+        self.pools = []
+        model.to(self.gdv)
+        self.pools.append(nid)
+        next_id = nid
+        for i in range(self.win_size-1):
+            next_id = self.nears[next_id][0]
+            if next_id<0:
+                break
+            self.nets[next_id].to(self.gdv)
+            self.pools.append(next_id)
+    def hook_forward(self, model, ins, outs):
+        self.no_caches = True
+    def hook_forward_pre(self, model, ins):
+        self.no_caches = False
+        nid = id(model)
+        if nid not in self.pools:
+            self.copy_forward(nid, model)
+        if self.curr>=0:
+            self.nears[self.curr][0] = nid
+        self.curr = nid
+        return self.fc_inputs_to(ins, self.gdv)
+    def do_forward(self, fc):
+        self.no_caches = True
+        self.ctxs = {k:[] for k in self.nets}
+        with torch.autograd.graph.saved_tensors_hooks(self.hook_pack, self.hook_unpack):
+            rst = fc()
+        return rst.to(self.gdv)
+    def wrap_backward_deal(self, net_id):
+        if self.backward_deal is None:
+            return
+        self.backward_deal(self.nets[net_id], self.opts[net_id])
+    def hook_backward(self, model, grad_ins, grad_outs):
+        nid = id(model)
+        self.wrap_backward_deal(nid)
+    def hook_pack(self, dt):
+        if self.no_caches:
+            # 不做缓存，数据不处理
+            return -1, dt
+        index = self.curr
+        # forward时候为了后面计算梯度存的缓存，放到列表里方便转cpu和gpu
+        self.ctxs[index].append(dt)
+        return index, len(self.ctxs[index])-1
+    def hook_unpack(self, x):
+        nid = x[0]
+        if nid<0:
+            return x[1]
+        if nid not in self.pools:
+            self.copy_backward(nid)
+        dt = self.ctxs[nid][x[1]]
+        if self.curr>=0:
+            self.nears[self.curr][1] = nid
+        self.curr = nid
+        return dt
+    def do_backward(self, fc):
+        self.curr = -1
+        fc()

buildz-0.7.3/buildz/iocz/__init__.py

@@ -0,0 +1,6 @@
+#
+
+'''
+buildz.ioc代码重构，感觉原代码变得复杂不好扩展，或者扩展起来感觉难受的时候，就会想要进行结构化重构
+'''
+from .init import *

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/mhttp/gateway.py

@@ -79,7 +79,7 @@ class GWDealer(proxy.ProxyDealer):
 
 class Gateway(proxy.Proxy):
     '''
-        类似nginx的前向代理
+        类似nginx的反向代理
     '''
     def init(self, addr, rules, fp_cert=None, fp_prv=None, password = None,listen=5, record=None, cafile=None, capath=None, cadata=None,check_hostname=True):
         super().init(addr, listen, record)

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/mhttp/mhttp.py

@@ -87,7 +87,7 @@ def http_encode_send(http_type, url, headers=None, data_size=0, protocol = "HTTP
         port = 0
     if len(addrs)>1:
         port = int(addrs[1])
-    quest= f"{http_type.upper()} {url} {protocol}".encode("utf-8") #HTTPS TODO
+    quest= f"{http_type.upper()} {url} {protocol}".encode("utf-8")
     if headers is None:
         headers = {}
     if 'Host' not in headers:
@@ -103,8 +103,8 @@ pass
 def chunked_encode(data):
     n = hex(len(data))[2:].encode()
     return n+b"\r\n"+data+b"\r\n"
-def readable(skt):
-    (rlist,wlist,elist)=select.select([skt],[],[],0)
+def readable(skt,timeout=0):
+    (rlist,wlist,elist)=select.select([skt],[],[],timeout)
     return len(rlist)>0
 def chunked_data(skt):
     dt = skt.readline().strip().decode()
@@ -250,4 +250,4 @@ class HttpMonitor(Base):
                 if n==0:
                     break
         fc_done()
-        return bak
+        return line, headers, data

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/mhttp/proxy.py

@@ -49,7 +49,6 @@ class ProxyDealer(Base):
         self.record.response(line, headers, data_size)
         protocol, code, rsp_text = line
         bts = mhttp.http_encode_rsp(code, rsp_text, headers, data_size, protocol)
-        print(f"[TESTZ] bts send: {bts}")
         skt_cli.send(bts)
         if data_size>0:
             data = skt.read(data_size)
@@ -166,15 +165,20 @@ class Proxy(Base):
         self.skt.close()
     def make_dealer(self, skt, addr):
         return ProxyDealer(skt, record=self.record.clone())
-    def call(self):
+    def call(self, wait_time=0.1):
         self.running=True
         skt = socket.socket()
         skt.bind(self.addr)
         skt.listen(self.listen)
         self.skt = skt
-        while self.running:
-            skt,addr = self.skt.accept()
-            deal = self.make_dealer(skt, addr)
-            th = threading.Thread(target=deal,daemon=True)
-            th.start()
-            self.ths.append(th)
+        try:
+            while self.running:
+                while not mhttp.readable(self.skt,wait_time):
+                    pass
+                skt,addr = self.skt.accept()
+                deal = self.make_dealer(skt, addr)
+                th = threading.Thread(target=deal,daemon=True)
+                th.start()
+                self.ths.append(th)
+        finally:
+            self.close()

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/mhttp/record.py

@@ -6,6 +6,12 @@ class MsgRecord(Base):
         要多线程安全，可以考虑：
             1，修改clone方法，新建一个MsgRecord实例而非返回self，并且自己加锁
             2，通过threading.current_thread().ident获取线程id，然后做相应处理
+        需要实现的方法：
+            _start: 新的请求/响应报文进来时调用，传入头部信息等
+            _add: 传入报文体数据
+            _add_chunk: 传入chunk数据
+            _finish: 请求/响应报文数据已全部传入，看是否需要做什么处理
+            实现可参考MsgLog
     """
     TypeReq ="request"
     TypeRsp = "response"
@@ -17,6 +23,10 @@ class MsgRecord(Base):
         self.ssl = False
         self.ssl_update()
     def set_ssl(self, ssl=True):
+        '''
+            声明当前连接转ssl或者从ssl转tcp，看是否需要在ssl_update做什么处理
+            不管连接是ssl还是tcp，传入start，add，add_chunk方法里的数据都是明文
+        '''
         self.ssl = ssl
         self.ssl_update()
     def start(self, msg_type, line, headers, data_size):
@@ -47,7 +57,7 @@ class MsgRecord(Base):
             protocol: 应该都是HTTP/1.1或HTTP/1.0
             code: 响应数据编码,200、404等
             rsp_text: 响应数据文本, OK, Not Found等
-        headers: http头部信息
+        headers: http头部信息, dict（字典）数据
         data_size: 当前报文的报文体数据大小（不包括chunk部分）
         """
         pass

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/tcp/middle.py

@@ -17,11 +17,11 @@ class MiddleServer(Base):
         self.running = False
         self.wait = wait
         self.pairs = {}
-        self.lock = threading.Lock()
+        #self.lock = threading.Lock()
     def close_pair(self, a, b):
-        with self.lock:
-            del self.pairs[id(a)]
-            del self.pairs[id(b)]
+        #with self.lock:
+        del self.pairs[id(a)]
+        del self.pairs[id(b)]
         log("close").info(f"pair {a.getpeername()}, {b.getpeername()} close")
         for c in (a,b):
             try:
@@ -42,17 +42,9 @@ class MiddleServer(Base):
             log.warn(f"traceback: {traceback.format_exc()}")
             self.close_pair(skt_read, skt_write)
     def connects(self):
-        with self.lock:
-            arr = [v[0] for k,v in self.pairs.items()]
+        #with self.lock:
+        arr = [v[0] for k,v in self.pairs.items()]
         return arr
-    def deals(self):
-        while self.running:
-            if len(self.pairs)==0:
-                time.sleep(self.wait)
-                continue
-            (rlist,wlist,elist)=select.select(self.connects(),[],[],0)
-            for skt in rlist:
-                self.deal(skt)
     def add(self, skt_cli, addr):
         try:
             skt_srv = socket.socket()
@@ -63,20 +55,35 @@ class MiddleServer(Base):
             skt_cli.close()
             return
         log("connect").info(f"build pair from {skt_cli.getpeername()} to {skt_srv.getpeername()}")
-        with self.lock:
-            self.pairs[id(skt_cli)] = (skt_cli, skt_srv)
-            self.pairs[id(skt_srv)] = (skt_srv, skt_cli)
+        #with self.lock:
+        self.pairs[id(skt_cli)] = (skt_cli, skt_srv)
+        self.pairs[id(skt_srv)] = (skt_srv, skt_cli)
     def call(self, fc_stop = None):
-        if fc_stop is None:
-            fc_stop = lambda :False
         self.running=True
-        threading.Thread(target=self.waits,daemon=True).start()
-        threading.Thread(target=self.deals,daemon=True).start()
-        try:
-            while not fc_stop():
-                time.sleep(1.0)
-        finally:
-            self.running=False
+        if fc_stop is None:
+            return self.waits_and_deals()
+        else:
+            threading.Thread(target=self.waits_and_deals,daemon=True).start()
+            try:
+                while not fc_stop():
+                    time.sleep(1.0)
+            finally:
+                self.running=False
+    def waits_and_deals(self):
+        skt = socket.socket()
+        skt.bind(self.addr)
+        skt.listen(self.listen)
+        self.skt = skt
+        while self.running:
+            skts = self.connects()
+            skts.append(self.skt)
+            (rlist,wlist,elist)=select.select(skts,[],[],self.wait)
+            for skt in rlist:
+                if skt == self.skt:
+                    _skt,addr = self.skt.accept()
+                    self.add(_skt, addr)
+                else:
+                    self.deal(skt)
     def waits(self):
         skt = socket.socket()
         skt.bind(self.addr)
@@ -85,6 +92,14 @@ class MiddleServer(Base):
         while self.running:
             skt,addr = self.skt.accept()
             self.add(skt, addr)
+    def deals(self):
+        while self.running:
+            if len(self.pairs)==0:
+                time.sleep(self.wait)
+                continue
+            (rlist,wlist,elist)=select.select(self.connects(),[],[],0)
+            for skt in rlist:
+                self.deal(skt)
 
 pass
 

{buildz-0.7.1 → buildz-0.7.3}/buildz/netz/test/test_gw.py

@@ -31,3 +31,11 @@ def gw():
 #pyz.lc(locals(), caps)
 pyz.lc(locals(), gw)
 
+'''
+cli:
+import requests as rq
+url="http://127.0.0.1:9999/baidu"
+rp = rq.get(url)
+print(rp)
+
+'''

buildz-0.7.3/buildz/xf/__init__.py

@@ -0,0 +1,21 @@
+
+
+#print("xf.__init__")
+from .readz import loads, load, loadf, loads_args, loadx, is_args, loadxf
+from .writez import dumps, dump, dumpf, dumpx, dumpxf
+from .file import *
+from .mapz import *
+from .xargs import fetch as args
+
+try:
+    # C++加速代码
+    #from .cpp import pcxf
+    #print(f"pcxf:", pcxf)
+    #print(f"pcxf.loads:", dir(pcxf))
+    from buildz.xf.cpp.pcxf import loads, loadx
+    loads_args = loadx
+except Exception as exp:
+    #print("init not cpp:",exp)
+    pass
+pass
+__author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"

buildz-0.7.3/buildz/xf/base.py

@@ -0,0 +1,30 @@
+
+from buildz import Base, Args
+# class Args(Base):
+#     def size(self):
+#         return len(self.args)+len(self.maps)
+#     def str(self):
+#         return f"<Args args={self.args}, maps={self.maps}>"
+#     @property
+#     def lists(self):
+#         return self.args
+#     @lists.setter
+#     def lists(self, val):
+#         self.args=val
+#     @lists.deleter
+#     def lists(self):
+#         del self.args
+#     @property
+#     def dicts(self):
+#         return self.maps
+#     @dicts.setter
+#     def dicts(self, val):
+#         self.maps=val
+#     @dicts.deleter
+#     def dicts(self):
+#         del self.maps
+#     def init(self, args, maps):
+#         self.args = args
+#         self.maps = maps
+
+# pass

buildz-0.7.3/buildz/xf/cpp/Makefile

@@ -0,0 +1,24 @@
+.PHONY: cpp_depend ALL
+TARGETLIB = libcxf.a
+TARGETLIB_CPP = cxf
+TARGETDYN=cxf.so
+SRC=$(wildcard loaderz/*.cpp) $(wildcard loaderz/**/*.cpp)
+OBJ=$(SRC:.cpp=.o)
+ALL:$(TARGETLIB) $(TARGETDYN)
+	echo "$(SRC)"
+
+$(TARGETDYN):$(OBJ)
+	g++ -O3 -fPIC -shared -o $@ $^ -static-libstdc++ -static-libgcc
+$(TARGETLIB): $(OBJ)
+	ar -rc $@ $^
+test: $(OBJ)
+	g++ -O3 $^ -o $@
+%.o:%.cpp
+	g++ -O3 -fPIC -Wall -g -c $< -o $@
+
+include cpp_depend
+cpp_depend:
+	g++ -MM $(SRC) > cpp_depend
+
+clean:
+	rm $(OBJ)