buildz 0.9.4__tar.gz → 0.9.6__tar.gz

{buildz-0.9.4/buildz.egg-info → buildz-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.4
+Version: 0.9.6
 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

{buildz-0.9.4 → buildz-0.9.6}/buildz/_dz/conf.py

@@ -257,7 +257,7 @@ class Conf(Base):
         # TODO
         keys = dzkeys(key, self.spt)
         return mapz.dremove(self.conf, keys)
-    def _has(self, key, link=0):
+    def _has(self, key, link=-1):
         return self._hget(key, None, link)[1]
         keys = dzkeys(key, self.spt)
         return mapz.dhas(self.conf, keys)
@@ -272,7 +272,7 @@ class Conf(Base):
         return rst
     def s(self, **maps):
         [self.set(k,v) for k,v in maps.items()]
-    def has_all(self, keys, link = 0):
+    def has_all(self, keys, link = -1):
         keys = self.spts_ks(keys)
         rst = [1-self.has(key, link) for key in keys]
         return sum(rst)==0

{buildz-0.9.4 → buildz-0.9.6}/buildz/confz.py

@@ -19,6 +19,8 @@ def load_conf(conf, dp=None, dp_key = 'dp', src_key = 'src.conf'):
         rst.update(base, flush, replace, visit_list)
     for fp in fps:
         tmp = xf.loadf(path.dp(fp))
+        if type(tmp)!=dict:
+            continue
         rst.update(tmp, flush, replace, visit_list)
     if not conf_first:
         rst.update(base, flush, replace, visit_list)

{buildz-0.9.4 → buildz-0.9.6}/buildz/gpuz/test/demo.py

@@ -13,7 +13,13 @@ class TestDataset(Dataset):
         return self.num
     def __getitem__(self, i):
         return self.datas[i], self.targets[i]
-dims = 12
+dims = 3
+"""
+cd D:\rootz\python\gits\buildz_upd\buildz\gpuz\test
+D:
+python -m buildz.gpuz.test.demo > demo.txt
+
+"""
 dataset = TestDataset(30, dims)
 dataloader = DataLoader(dataset, 10)
 class MiniModel(nn.Module):
@@ -25,7 +31,7 @@ class MiniModel(nn.Module):
         self.nets = nn.Sequential(*nets)
     def forward(self, inputs):
         return self.nets(inputs)
-models = [MiniModel(dims, 32, 3) for i in range(10)]
+models = [MiniModel(dims, 6, 3) for i in range(6)]
 opts = [optim.Adam(model.parameters(), lr=0.001) for model in models]
 #可以指定哪些模型全部放cuda或者全部放cpu
 cuda_models = [models[1],models[2]]
@@ -38,7 +44,7 @@ def opt_step(net, opt):
     # 另外，opt不一定就是优化函数，可以是任何数据，其只取决于创建DictCache的时候传入的opts是什么
     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])
+cache = DictCache([torch.device('cuda'), torch.device('cpu')],models,opts,3,opt_step)#, [cuda_models,cpu_models])
 
 # 训练:
 [md.train() for md in models]
@@ -50,6 +56,9 @@ for inputs,targets in dataloader:
     cache.do_backward(lambda: loss.backward())
     # opt.step()在do_backward里会自动调用
     print(loss.item())
+    break
+
+exit()
 
 # 测试:
 inputs = torch.rand(1, dims).cuda()

buildz-0.9.6/buildz/gpuz/test/dm.py

@@ -0,0 +1,89 @@
+
+from buildz.gpuz.torch import DictCache
+import torch
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+class TestDataset(Dataset):
+    def __init__(self, num, dims):
+        self.num = num
+        self.dims = dims
+        self.datas = torch.rand(num, dims)
+        self.targets = torch.rand(num, dims)
+    def __len__(self):
+        return self.num
+    def __getitem__(self, i):
+        return self.datas[i], self.targets[i]
+dims = 64
+"""
+cd D:\rootz\python\gits\buildz_upd\buildz\gpuz\test
+D:
+python -m buildz.gpuz.test.demo > demo.txt
+
+"""
+dataset = TestDataset(90, dims)
+dataloader = DataLoader(dataset, 30)
+class MiniModel(nn.Module):
+    def __init__(self, dims, mdims, num):
+        super().__init__()
+        nets = [nn.Linear(dims, mdims)]
+        nets += [nn.Linear(mdims,mdims) for i in range(num)]
+        nets.append(nn.Linear(mdims,dims))
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+models = [MiniModel(dims, 32, 3) for i in range(6)]
+opts = [optim.Adam(model.parameters(), lr=0.001) for model in models]
+#可以指定哪些模型全部放cuda或者全部放cpu
+cuda_models = [models[1],models[2]]
+cpu_models = [models[-1]]
+real_model = nn.Sequential(*models)
+loss_fn = torch.nn.MSELoss()
+def opt_step(net, opt):
+    # 如果模型只是用来测试，不做训练，可以不传该函数，同时opts传入空就可以
+    # 对模型的一些其他优化，可以写可以不写，主要是调用opt.step()进行当前小模型的模型训练
+    # 另外，opt不一定就是优化函数，可以是任何数据，其只取决于创建DictCache的时候传入的opts是什么
+    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])
+
+# 训练:
+def train():
+    [md.train() for md in models]
+    for inputs,targets in dataloader:
+        inputs,targets = inputs.cuda(),targets.cuda()
+        [opt.zero_grad() for opt in opts]
+        outs = cache.do_forward(lambda:real_model(inputs))
+        loss = loss_fn(outs, targets)
+        cache.do_backward(lambda: loss.backward())
+        # opt.step()在do_backward里会自动调用
+        #print(loss.item())
+        #break
+pass
+import time
+print("start")
+start = time.time()
+for i in range(50):
+    train()
+sec = time.time()-start
+print("time cost:", sec)
+"""
+from buildz.gpuz.test import dm
+
+ws = []
+for md in dm.models:
+    for net in md.nets:
+        ws.append(net.weight.cpu().detach().clone())
+
+pass
+
+dm.train()
+
+nws = []
+for md in dm.models:
+    for net in md.nets:
+        nws.append(net.weight.cpu().detach().clone())
+
+pass
+subs = [(a-b).sum() for a,b in zip(ws, nws)]
+
+"""

buildz-0.9.6/buildz/gpuz/test/dm1.py

@@ -0,0 +1,124 @@
+
+from buildz.gpuz.torch.middle_cache import MiddleCache
+import torch
+from torch import nn,optim
+from torch.utils.data import DataLoader, Dataset
+class TestDataset(Dataset):
+    def __init__(self, num, dims):
+        self.num = num
+        self.dims = dims
+        self.datas = torch.rand(num, dims)
+        self.targets = torch.rand(num, dims)
+    def __len__(self):
+        return self.num
+    def __getitem__(self, i):
+        return self.datas[i], self.targets[i]
+dims = 64
+"""
+cd D:\rootz\python\gits\buildz_upd\buildz\gpuz\test
+D:
+python -m buildz.gpuz.test.demo > demo.txt
+
+"""
+dataset = TestDataset(90, dims)
+dataloader = DataLoader(dataset, 30)
+class MiniModel(nn.Module):
+    def __init__(self, dims, mdims, num):
+        super().__init__()
+        nets = [nn.Linear(dims, mdims)]
+        nets += [nn.Linear(mdims,mdims) for i in range(num)]
+        nets.append(nn.Linear(mdims,dims))
+        self.nets = nn.Sequential(*nets)
+    def forward(self, inputs):
+        return self.nets(inputs)
+models = [MiniModel(dims, 32, 3) for i in range(6)]
+#opts = [optim.Adam(model.parameters(), lr=0.001) for model in models]
+real_model = nn.Sequential(*models)
+opt = optim.Adam(real_model.parameters(), lr=0.001)
+#可以指定哪些模型全部放cuda或者全部放cpu
+cuda_models = [models[1],models[2]]
+cpu_models = [models[-1]]
+loss_fn = torch.nn.MSELoss()
+cache = MiddleCache(models, 3)#, cal_dv = "cpu", cal_nets = cuda_models, cache_nets = cpu_models)#, [torch.device('cuda'), torch.device('cpu')],models,opts,3,opt_step)#, [cuda_models,cpu_models])
+
+# 训练:
+def train():
+    cache.train()
+    for inputs,targets in dataloader:
+        targets = targets.cuda()
+        #inputs,targets = inputs.cuda(),targets.cuda()
+        opt.zero_grad()
+        with cache.wrap_forward():
+            outs = real_model(inputs)
+        loss = loss_fn(outs, targets)
+        with cache.wrap_backward():
+            loss.backward()
+        torch.nn.utils.clip_grad_norm_(real_model.parameters(), max_norm=1.0)
+        opt.step()
+        #cache.do_backward(lambda: loss.backward())
+        # opt.step()在do_backward里会自动调用
+        # print(loss.item())
+        # break
+        #break
+pass
+import time
+print("start")
+start = time.time()
+for i in range(50):
+    train()
+sec = time.time()-start
+print("time cost:", sec)
+
+"""
+python -m buildz.gpuz.test.dm1
+
+from buildz.gpuz.test import dm1 as dm
+
+dm.cache.train()
+inputs, targets = list(dm.dataloader)[0]
+dm.opt.zero_grad()
+with dm.cache.wrap_forward():
+    outs = dm.real_model(inputs)
+
+pass
+
+ks = list(dm.cache.datas.keys())
+dts0 = dm.cache.datas[ks[0]]
+net0 = dm.cache.nets[ks[0]]
+[k.shape for k in dts0]
+
+
+dts1 = dm.cache.datas[ks[1]]
+net1 = dm.cache.nets[ks[1]]
+[k.shape for k in dts1]
+
+
+ws = []
+for md in dm.models:
+    for net in md.nets:
+        ws.append(net.weight.cpu().detach().clone())
+
+pass
+
+dm.train()
+
+nws = []
+for md in dm.models:
+    for net in md.nets:
+        nws.append(net.weight.cpu().detach().clone())
+
+pass
+subs = [(a-b).sum() for a,b in zip(ws, nws)]
+
+w0 = dm.models[0].nets[-1].weight.cpu().detach()
+w1 = dm.models[1].nets[0].weight.cpu().detach()
+
+dm.train()
+
+nw0 = dm.models[0].nets[-1].weight.cpu().detach()
+nw1 = dm.models[1].nets[0].weight.cpu().detach()
+
+(w0-nw0).sum()
+(w1-nw1).sum()
+
+"""

{buildz-0.9.4 → buildz-0.9.6}/buildz/gpuz/torch/__init__.py

@@ -5,6 +5,9 @@ __version__="0.0.1"
 __author__ = "Zzz, emails: 1174534295@qq.com, 1309458652@qq.com"
 # 小号多
 
+from .middle_cache import MiddleCache
+
+# 下面的dict_middle也弃了，上面的MiddleCache写的更合理
 from .dict_middle import DictCache, Fcs
 #from .dict_middle import *
 Dict = DictCache

{buildz-0.9.4 → buildz-0.9.6}/buildz/gpuz/torch/dict_middle.py

@@ -227,6 +227,7 @@ class DictCache(Base):
     def hook_forward_pre(self, model, ins):
         self.no_caches = False
         nid = id(model)
+        #print(f"hook_forward_pre {nid}")
         if nid not in self.pools:
             self.copy_forward(nid, model)
         if self.curr>=0:
@@ -234,10 +235,12 @@ class DictCache(Base):
         self.curr = nid
         return self.fc_inputs_to(ins, self.gdv)
     def do_forward(self, fc):
+        #print("FWD")
         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()
+        #print("DFWD")
         return rst.to(self.gdv)
     def wrap_backward_deal(self, net_id):
         if self.backward_deal is None:
@@ -245,8 +248,10 @@ class DictCache(Base):
         self.backward_deal(self.nets[net_id], self.opts[net_id])
     def hook_backward(self, model, grad_ins, grad_outs):
         nid = id(model)
+        #print(f"hook_backward {nid}")
         self.wrap_backward_deal(nid)
     def hook_pack(self, dt):
+        #print(f"pack")
         if self.no_caches:
             # 不做缓存，数据不处理
             return -1, dt
@@ -256,6 +261,7 @@ class DictCache(Base):
         return index, len(self.ctxs[index])-1
     def hook_unpack(self, x):
         nid = x[0]
+        #print(f"unpack {nid}")
         if nid<0:
             return x[1]
         if nid not in self.pools:

buildz-0.9.6/buildz/gpuz/torch/middle_base.py

@@ -0,0 +1,80 @@
+#
+'''
+model.register_forward_pre_hook 会在模型forward之前调用
+model.register_forward_hook 会在模型forward之后调用
+model.register_full_backward_hook 会在模型反向梯度计算之后调用，注，模型列表第一个模型会在计算梯度前调用，该hook参数是(model, grad_ins, grad_outs),model是当前模型，grad_outs是后面的模型传来的，grad_ins是grad_outs经过该model计算后往前传的梯度，好像是第一个模型因为不用往前传梯度，提前调用了
+torch.autograd.graph.saved_tensors_hooks(hook_pack, hook_unpack):
+    hook_pack会在Tensor计算完成后把之后反向梯度计算要用的tensor进行存储
+    hook_unpack是在Tensor反向梯度计算前取回之前存储的tensor，注：调用loss.backward不用在with ...saved_tensors_hooks(..)中
+'''
+
+import torch
+from ... import Base
+from ... import pyz
+class MiddleBase(Base):
+    def init(self, nets):
+        self.hook(nets)
+    def before_forward(self):
+        pass
+    def after_forward(self):
+        pass
+    def before_backward(self):
+        pass
+    def after_backward(self):
+        pass
+    def hook_forward_before(self, model, ins):
+        return ins.cpu()
+    def hook_forward_after(self, model):
+        pass
+    def hook_backward_after(self, model):
+        pass
+    def tensor_save(self, tuple_data):
+        obj = tuple_data
+        return obj
+    def tensor_load(self, obj):
+        tuple_data = obj
+        return tuple_data
+    # 下面是不应修改的部分
+    def hook(self, nets):
+        net = nets[0]
+        self.start_id = id(net)
+        self.start_net = net
+        hooks = []
+        hooks += [net.register_forward_pre_hook(self.hook_forward_before) for net in nets]
+        hooks+=[net.register_forward_hook(self.native_hook_forward_after) for net in nets]
+        if hasattr(self.start_net, "register_full_backward_hook"):
+            hooks+=[net.register_full_backward_hook(self.native_hook_backward_after) for net in nets]
+        else:
+            hooks+=[net.register_backward_hook(self.native_hook_backward_after) for net in nets]
+        self.hooks = hooks
+    def unhook(self):
+        [hook.remove() for hook in self.hooks]
+    def do_forward(self, fc):
+        with self.wrap_forward():
+            return fc()
+    def do_backward(self, fc):
+        with self.wrap_backward():
+            return fc()
+    def wrap_backward(self):
+        def wrap_enter():
+            self.before_backward()
+        def wrap_out(exc_type, exc_val, exc_tb):
+            self.hook_backward_after(self.start_net)
+            self.after_backward()
+        return pyz.With(wrap_enter, wrap_out, True)
+    def wrap_forward(self):
+        obj = torch.autograd.graph.saved_tensors_hooks(self.tensor_save, self.tensor_load)
+        def wrap_enter():
+            self.before_forward()
+            obj.__enter__()
+        def wrap_out(exc_type, exc_val, exc_tb):
+            obj.__exit__(exc_type, exc_val, exc_tb)
+            self.after_forward()
+        return pyz.With(wrap_enter, wrap_out, True)
+    def native_hook_backward_after(self, model, grad_up, grad_src):
+        if id(model)==self.start_id:
+            return
+        self.hook_backward_after(model)
+    def native_hook_forward_after(self, model, ins, outs):
+        self.hook_forward_after(model)
+pass

buildz-0.9.6/buildz/gpuz/torch/middle_cache.py

@@ -0,0 +1,143 @@
+#
+
+from .middle_base import MiddleBase
+import torch
+class MiddleCache(MiddleBase):
+    '''
+        nets: 模型列表
+        win_size: gpu设备可存放的模型数量
+        deal_after_backup: fc(model) 或 None, 在模型进行backward后调用
+        cal_dv: 计算设备，默认cuda
+        cache_dv: 缓存设备，默认cpu
+        fc_inputs_to: fc(inputs, dv) 或 None, 需要把输入参数转换成设备dv对应的数据时候使用，默认输入参数是Tensor的tuple或者就是Tensor
+        cal_nets: 模型列表，nets中的一部分，不进行两个设备转换，而是一直放在cal_dv上的模型
+        cache_nets: 模型列表，nets中的一部分，不进行两个设备转换，而是一直放在cache_dv上的模型
+        preload: 预加载，把模型加载到计算设备时，把后面的模型也加载到计算设备上（已经加载到计算设备上的放缓存设备中）
+    '''
+    def init(self, nets, win_size=1, deal_after_backup=None, cal_dv='cuda', cache_dv='cpu', fc_inputs_to = None, cal_nets = [], cache_nets = [], preload = False):
+        cache_dv = torch.device(cache_dv) if type(cache_dv)==str else cache_dv
+        cal_dv = torch.device(cal_dv) if type(cal_dv)==str else cal_dv
+        [net.to(cache_dv) for net in cache_nets]
+        [net.to(cal_dv) for net in cal_nets]
+        self.src = nets
+        static_dv = {}
+        static_dv.update({id(net):cache_dv for net in cache_nets})
+        static_dv.update({id(net):cal_dv for net in cal_nets})
+        self.static_dv = static_dv
+        self.nets = {id(net):net for net in nets if id(net) not in self.static_dv}
+        # TEST CODE
+        # self.indexes = {}
+        # for i in range(len(nets)):
+        #     self.indexes[id(nets[i])] = i
+        # DONE
+        self.cache_dv = cache_dv
+        self.cal_dv = cal_dv
+        self.hook(nets)
+        # 
+        self.datas = {id(net):[] for net in nets}
+        self.cal_ids = []
+        self.deal_after_backup = deal_after_backup
+        if fc_inputs_to is None:
+            fc_inputs_to = self.list_inputs_to
+        self.inputs_to = fc_inputs_to
+        self.nexts = {}
+        self.prevs = {}
+        self.curr = -1
+        self.mark_static = None
+        self.win_size = win_size
+        self.preload = preload
+    def train(self):
+        [net.train() for net in self.src]
+    def eval(self):
+        [net.eval() for net in self.src]
+    @staticmethod
+    def list_inputs_to(datas, dv):
+        if isinstance(datas, torch.Tensor):
+            return datas.to(dv)
+        # assert datas is not None, "inputs datas is null"
+        inputs = tuple([k.to(dv) for k in datas])
+        return inputs
+    def before_forward(self):
+        self.curr = -1
+        for mid in self.datas:
+            self.datas[mid] = []
+    def after_forward(self):
+        pass
+    def before_backward(self):
+        self.curr = -1
+    def after_backward(self):
+        pass
+    def to_dv(self, mid, dv):
+        self.nets[mid].to(dv)
+        self.datas[mid] = [self.inputs_to(k, dv) if k is not None else k for k in self.datas[mid]]
+    def to_cal(self, mid, pop = 0):
+        if mid in self.cal_ids:
+            return 0
+        if len(self.cal_ids)>=self.win_size:
+            xid = self.cal_ids.pop(pop)
+            #print(f"model_{self.indexes[xid]} to CPU device")
+            self.to_dv(xid, self.cache_dv)
+        #print(f"model_{self.indexes[mid]} to CUDA device")
+        self.to_dv(mid, self.cal_dv)
+        if pop==-1:
+            self.cal_ids = [mid]+self.cal_ids
+        else:
+            self.cal_ids.append(mid)
+        return 1
+    def hook_forward_before(self, model, ins):
+        mid = id(model)
+        self.mark_static = mid in self.static_dv
+        if self.mark_static:
+            # assert ins is not None, "hook_forward_before A"
+            return self.inputs_to(ins, self.static_dv[mid])
+        prev = self.curr
+        if prev >= 0:
+            self.nexts[prev] = mid
+            if mid not in self.prevs:
+                self.prevs[mid] = prev
+        self.curr = mid
+        self.loop_to_cal(mid, 0, self.nexts)
+        # assert ins is not None, "hook_forward_before B"
+        return self.inputs_to(ins, self.cal_dv)
+    def hook_forward_after(self, model):
+        pass
+    def hook_backward_after(self, model):
+        mid = id(model)
+        if self.deal_after_backup is not None:
+            self.deal_after_backup(model)
+        if id in self.static_dv:
+            return
+        after = self.curr
+        if after>=0:
+            self.prevs[after] = mid
+        self.curr = mid
+    def tensor_save(self, tuple_data):
+        if self.mark_static:
+            return -1, tuple_data
+        index = len(self.datas[self.curr])
+        self.datas[self.curr].append(tuple_data)
+        return self.curr, index
+    def tensor_load(self, obj):
+        if obj[0]<0:
+            return obj[1]
+        curr, index = obj
+        self.loop_to_cal(curr, -1, self.prevs)
+        tuple_data = self.datas[curr][index]
+        # assert tuple_data is not None
+        self.datas[curr][index] = None
+        return tuple_data
+    def loop_to_cal(self, mid, pop, nexts):
+        if mid in self.cal_ids:
+            return
+        self.to_cal(mid, pop)
+        if not self.preload:
+            return
+        count = 1
+        while count<self.win_size and mid in nexts:
+            mid = nexts[mid]
+            if mid in self.cal_ids:
+                break
+            self.to_cal(mid, pop)
+            count+=1
+            
+pass

buildz-0.9.6/buildz/path.py

@@ -0,0 +1,79 @@
+from . import Base
+import os,sys,json,time
+class Key:
+    first='first'
+    ifirst = 0
+    last= 'last'
+    ilast = -1
+    @staticmethod
+    def check_first(val):
+        return val in (Key.first, Key.ifirst)
+    @staticmethod
+    def check_last(val):
+        return val in (Key.last, Key.ilast)
+class Path(Base):
+    Key = Key
+    def init(self, **maps):
+        self.paths = {}
+        self.fcs = {}
+        self.lasts = {}
+        k = "check_abs"
+        self.check_abs = True
+        if k in maps:
+            self.check_abs = maps[k]
+            del maps[k]
+        for k, v in maps.items():
+            self.set(k, v)
+    @staticmethod
+    def dir(fp):
+        return os.path.dirname(fp)
+    @staticmethod
+    def join(*a):
+        return os.path.join(*a)
+    @staticmethod
+    def rjoin(path, *a):
+        a = [k.strip() for k in a if k is not None and k.strip()!=""]
+        if len(a)==0:
+            return None
+        if path is None:
+            return os.path.join(*a)
+        return os.path.join(path, *a)
+    @staticmethod
+    def rfp(paths, *a, last=-1, check_abs=False):
+        a = [k.strip() for k in a if k is not None and k.strip()!=""]
+        if len(a)==0:
+            return None
+        if check_abs and len(a)>0:
+            f = a[0]
+            if f[:1]=="/" or f.find(":")>0:
+                return Path.join(*a)
+        #print(f"[TESTZ] a: {a}, paths: {paths}")
+        #fp = os.path.join(*a)
+        for path in paths:
+            _fp = Path.rjoin(path, *a)
+            if os.path.exists(_fp):
+                return _fp
+        return Path.rjoin(paths[last], *a)
+    def add(self, path, name=None, index=0):
+        self.paths[name].insert(index, path)
+    def set(self, paths, name=None, last = -1, curr = None):
+        if type(paths) not in (list, tuple):
+            paths = [paths]
+        if curr is not None and None not in paths:
+            if Key.check_first(curr):
+                paths = [None]+paths
+            elif Key.check_last(curr):
+                paths.append(None)
+            else:
+                assert False
+        self.paths[name] = paths
+        self.lasts[name] = last
+        def fc(*a):
+            return self.rfp(paths, *a, last=last, check_abs=self.check_abs)
+        self.fcs[name] = fc
+    def __getattr__(self, name):
+        return self.fcs[name]
+    def call(self, *obj):
+        return self.fcs[None](*obj)
+
+pass

{buildz-0.9.4 → buildz-0.9.6/buildz.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: buildz
-Version: 0.9.4
+Version: 0.9.6
 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

{buildz-0.9.4 → buildz-0.9.6}/buildz.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ buildz/cmd.py
 buildz/confz.py
 buildz/dz.py
 buildz/logz.py
+buildz/path.py
 buildz/pathz.py
 buildz/pyz.py
 buildz/tls.py
@@ -119,6 +120,8 @@ buildz/fz/fio.py
 buildz/fz/lsf.py
 buildz/gpuz/test/analyze.py
 buildz/gpuz/test/demo.py
+buildz/gpuz/test/dm.py
+buildz/gpuz/test/dm1.py
 buildz/gpuz/test/report.txt
 buildz/gpuz/test/take_gpu_mem.py
 buildz/gpuz/test/test_atten_demo.py
@@ -127,6 +130,8 @@ buildz/gpuz/test/test_multi_demo.py
 buildz/gpuz/test/test_resnet_demo.py
 buildz/gpuz/torch/__init__.py
 buildz/gpuz/torch/dict_middle.py
+buildz/gpuz/torch/middle_base.py
+buildz/gpuz/torch/middle_cache.py
 buildz/gpuz/torch/multi_dict_middle.py
 buildz/gpuz/torch/seq_middle.py
 buildz/html/__init__.py

{buildz-0.9.4 → buildz-0.9.6}/setup.py

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