buildz 0.7.1__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.7.1
+Version: 0.7.2
 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.2}/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.2/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

{buildz-0.7.1 → buildz-0.7.2}/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.2}/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.2/buildz/iocz/__init__.py

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

{buildz-0.7.1 → buildz-0.7.2}/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.2}/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.2}/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.2}/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.2}/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.2}/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.1 → buildz-0.7.2/buildz.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.7.1
+Version: 0.7.2
 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.2}/setup.py

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

buildz-0.7.1/buildz/__init__.py

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

buildz-0.7.1/buildz/iocz/__init__.py

@@ -1,3 +0,0 @@
-#
-
-from .init import *