124 lines
2.5 KiB
Python
Executable File
124 lines
2.5 KiB
Python
Executable File
import json
|
|
from json import JSONEncoder
|
|
from inspect import ismethod, isfunction, isbuiltin, isabstract
|
|
|
|
def multiDict2Dict(md):
|
|
ns = {}
|
|
for k,v in md.items():
|
|
ov = ns.get(k,None)
|
|
if ov is None:
|
|
ns[k] = v
|
|
elif type(ov) == type([]):
|
|
ov.append(v)
|
|
ns[k] = ov
|
|
else:
|
|
ns[k] = [ov,v]
|
|
return ns
|
|
|
|
class DictObjectEncoder(JSONEncoder):
|
|
def default(self, o):
|
|
return o._addon()
|
|
|
|
class DictObject(dict):
|
|
def __getattr__(self, attr):
|
|
"""
|
|
实现点操作符访问字典中的键值对
|
|
"""
|
|
try:
|
|
v = self.__DOitem(self[attr])
|
|
self[attr] = v
|
|
except KeyError:
|
|
return None
|
|
|
|
def get_data_by_keys(self, keys):
|
|
try:
|
|
ks = keys.split('.', 1)
|
|
if '[' not in ks[0]:
|
|
d = getattr(self, ks[0])
|
|
if len(ks) == 1:
|
|
return d
|
|
if isinstance(d, DictObject):
|
|
return d.get_data_by_keys(ks[1])
|
|
return None
|
|
ks1 = ks[0].split('[', 1)
|
|
k = ks1[0]
|
|
idx = int(ks1[1].split(']',1)[0])
|
|
d = getattr(self, k)[idx]
|
|
if len(ks) == 1:
|
|
return d
|
|
if isinstance(d, DictObject):
|
|
return d.get_data_by_keys(ks[1])
|
|
return None
|
|
except:
|
|
return None
|
|
|
|
def __getitem__(self, key):
|
|
try:
|
|
v = self.__DOitem(super().__getitem__(key))
|
|
self[key] = v
|
|
return v
|
|
except KeyError:
|
|
return None
|
|
|
|
def __setattr__(self, attr, value):
|
|
"""
|
|
实现点操作符设置字典中的键值对
|
|
"""
|
|
self[attr] = value
|
|
|
|
def get(self, k, defv=None):
|
|
try:
|
|
v = self.__getitem__(k)
|
|
return v
|
|
except:
|
|
return defv
|
|
|
|
def copy(self):
|
|
return self.__DOitem(super().copy())
|
|
|
|
@classmethod
|
|
def isMe(self,name):
|
|
return name == 'DictObject'
|
|
|
|
def to_dict(self):
|
|
return self
|
|
|
|
def __DOArray(self,a):
|
|
b = [ self.__DOitem(i) for i in a ]
|
|
return b
|
|
|
|
def __DOitem(self, i):
|
|
if isinstance(i,DictObject):
|
|
return i
|
|
if isinstance(i,dict):
|
|
i = {k:v for k,v in i.items() if isinstance(k,str)}
|
|
try:
|
|
d = DictObject(**i)
|
|
return d
|
|
except Exception as e:
|
|
raise e
|
|
if type(i) == type([]) or type(i) == type(()) :
|
|
return self.__DOArray(i)
|
|
return i
|
|
|
|
def dictObjectFactory(_klassName__,**kwargs):
|
|
def findSubclass(_klassName__,klass):
|
|
for k in klass.__subclasses__():
|
|
if k.isMe(_klassName__):
|
|
return k
|
|
k1 = findSubclass(_klassName__,k)
|
|
if k1 is not None:
|
|
return k1
|
|
return None
|
|
try:
|
|
if _klassName__=='DictObject':
|
|
return DictObject(**kwargs)
|
|
k = findSubclass(_klassName__,DictObject)
|
|
if k is None:
|
|
return DictObject(**kwargs)
|
|
return k(**kwargs)
|
|
except Exception as e:
|
|
print("dictObjectFactory()",e,_klassName__)
|
|
raise e
|
|
|