class Results(object): def __init__(self, values): self.values = tuple([i[1] for i in values]) self.__keys = tuple([i[0] for i in values]) self.__dict = OrderedDict(values) def __iter__(self): return iter(self.values) def __getitem__(self, key): if isinstance(key, int): return self.values[key] else: return self.__dict[key] def __len__(self): return len(self.values) def __repr__(self): return "Results"+self.__dict.__repr__()[11:] def __str__(self): return "Results"+self.__dict.__str__()[11:] def __contains__(self, key): return True if key in self.__dict else False def get_keys(self): return self.__keys
class CStockChuQuanXiTemplate(object): def __init__(self): self.stockInfo = OrderedDict() self.stockInfo[stock_ChuQuanXi_ID] = None self.stockInfo[stock_ChuQuanXi_Name] = None self.stockInfo[stock_ChuQuanXi_Price] = None self.stockInfo[stock_ChuQuanXi_Day] = None self.stockInfo[stock_ChuQuanXi_ZhangDieFu] = None self.stockInfo[stock_ChuQuanXi_Detail] = None self.stockInfo[stock_ChuQuanXi_EXE_Day] = None self.stockInfo[stock_ChuQuanXi_NoticeDay] = None self.stockInfo[stock_ChuQuanXi_FenHong] = None self.stockInfo[stock_ChuQuanXi_HongLiLv] = None def initWithDict(self, dict_): for key in dict_: self.stockInfo[key] = dict_[key] def formatToDict(self): return self.stockInfo def getColunmInfo(self): return self.stockInfo.keys() def __str__(self): return self.stockInfo.__str__()
class CStockItemTemplate(object): def __init__(self): self.stockInfo = OrderedDict() self.stockInfo[stock_ID] = None self.stockInfo[stock_Name] = None self.stockInfo[stock_OpenPrice] = None self.stockInfo[stock_ClosePrice] = None self.stockInfo[stock_ClosePrice_Yesterday] = None self.stockInfo[stock_HighPrice] = None self.stockInfo[stock_LowerPrice] = None self.stockInfo[stock_Volumn] = None self.stockInfo[stock_Turnover] = None self.stockInfo[stock_Volumn_Ratio] = None self.stockInfo[stock_ZhangDieFu] = None self.stockInfo[stock_MA5] = None self.stockInfo[stock_MA10] = None self.stockInfo[stock_MA20] = None self.stockInfo[stock_MA30] = None self.stockInfo[stock_MA60] = None self.stockInfo[stock_MA120] = None self.stockInfo[stock_MA240] = None #indexs # 1. MACD self.stockInfo[stock_MACD] = None #2. BOLL self.stockInfo[stock_BOLLUp] = None self.stockInfo[stock_BOLLMid] = None self.stockInfo[stock_BOLLDown] = None self.stockInfo[stock_BOLL_Percent] = None self.stockInfo[stock_BOLL_Band_width] = None self.stockInfo[stock_CLOSE_TO_BOLLUP] = None self.stockInfo[stock_CLOSE_TO_BOLLMID] = None self.stockInfo[stock_CLOSE_TO_BOLLDOWN] = None self.stockInfo[stock_CLOSE_TO_BOLL_DOWN_TO_UP] = None self.stockInfo[stock_DISTANCE_MA_SHORT] = None self.stockInfo[stock_DISTANCE_MA_MID] = None self.stockInfo[stock_DISTANCE_MA_LONG] = None # # 3.RSI self.stockInfo[stock_RSI_6] = None self.stockInfo[stock_RSI_12] = None self.stockInfo[stock_RSI_24] = None #info self.stockInfo[stock_ShiZhi] = None self.stockInfo[stock_HangYe] = None self.stockInfo[stock_GaiNian] = None self.stockInfo[stock_Days] = None self.stockInfo[stock_XinTai] = None def __str__(self): return self.stockInfo.__str__()
class DictUtilitiesTest(unittest.TestCase): def test_inverse_dicts(self): self.dict1 = {1: [1, 2, 3], 2: [3, 4, 5]} self.dict2 = {2: [1], 3: [2], 4: [3, 4]} self.dict3 = {1: 2, 3: 4, 4: 4, 5: 4} self.dict4 = {2: 3, 4: 4} result = inverse_dicts(self.dict3) self.assertEqual({2: [1], 4: [3, 4, 5]}, result) result = inverse_dicts(self.dict1) self.assertEqual({1: [1], 2: [1], 3: [1, 2], 4: [2], 5: [2]}, result) result = inverse_dicts(self.dict3, self.dict4) self.assertEqual({2: [1], 3: [2], 4: [3, 4, 5, 4]}, result) result = inverse_dicts(self.dict1, self.dict2) self.assertEqual( { 1: [1, 2], 2: [1, 3], 3: [1, 2, 4], 4: [2, 4], 5: [2] }, result) def test_update_ordered_dict_key(self): self.ordered_dict = OrderedDict() self.ordered_dict["default"] = "Some stuff" self.ordered_dict["pythoncheck"] = "Somemore stuff" self.ordered_dict = update_ordered_dict_key(self.ordered_dict, "default", "coala") self.assertTrue("coala" in self.ordered_dict) self.assertEqual( "OrderedDict([('coala', 'Some stuff'), " "('pythoncheck', 'Somemore stuff')])", self.ordered_dict.__str__()) self.ordered_dict = update_ordered_dict_key(self.ordered_dict, "coala", "section") self.assertTrue("section" in self.ordered_dict) self.assertEqual( "OrderedDict([('section', 'Some stuff'), " "('pythoncheck', 'Somemore stuff')])", self.ordered_dict.__str__())
class DictUtilitiesTest(unittest.TestCase): def test_inverse_dicts(self): self.dict1 = {1: [1, 2, 3], 2: [3, 4, 5]} self.dict2 = {2: [1], 3: [2], 4: [3, 4]} self.dict3 = {1: 2, 3: 4, 4: 4, 5: 4} self.dict4 = {2: 3, 4: 4} result = inverse_dicts(self.dict3) self.assertEqual({2: [1], 4: [3, 4, 5]}, result) result = inverse_dicts(self.dict1) self.assertEqual({1: [1], 2: [1], 3: [1, 2], 4: [2], 5: [2]}, result) result = inverse_dicts(self.dict3, self.dict4) self.assertEqual({2: [1], 3: [2], 4: [3, 4, 5, 4]}, result) result = inverse_dicts(self.dict1, self.dict2) self.assertEqual({1: [1, 2], 2: [1, 3], 3: [1, 2, 4], 4: [2, 4], 5: [2]}, result) def test_update_ordered_dict_key(self): self.ordered_dict = OrderedDict() self.ordered_dict["default"] = "Some stuff" self.ordered_dict["pythoncheck"] = "Somemore stuff" self.ordered_dict = update_ordered_dict_key(self.ordered_dict, "default", "coala") self.assertTrue("coala" in self.ordered_dict) self.assertEqual("OrderedDict([('coala', 'Some stuff'), " "('pythoncheck', 'Somemore stuff')])", self.ordered_dict.__str__()) self.ordered_dict = update_ordered_dict_key(self.ordered_dict, "coala", "section") self.assertTrue("section" in self.ordered_dict) self.assertEqual("OrderedDict([('section', 'Some stuff'), " "('pythoncheck', 'Somemore stuff')])", self.ordered_dict.__str__())
def get_agent_state(self): """returns the current state of the agent in an ordered dict and a string of that dict""" inputs = self.env.sense(self) self.next_waypoint = self.planner.next_waypoint( ) # from route planner, also displayed by simulator state = OD(inputs.items() + [(x, y) for (x, y) in self.env.agent_states[self].items() if x in ['heading']] + [('waypoint', self.next_waypoint)]) return state, state.__str__()
class SourceManager(Service): """Source manager""" def __init__(self): Service.__init__(self) self._sources = OrderedDict() def _endSeq(self): # Dump items with LIFO order while len(self._sources) > 0: key, f = self._sources.popitem(last=True) def __str__(self): if self.logger.verbosityLevel == VerbosityLevels.DEBUG: for k, v in self._sources.items(): print(k, v) return self._sources.__str__() def __contains__(self, item): """See https://docs.python.org/3.7/reference/datamodel.html#emulating-container-types""" return item in self._sources def get(self, key, default=None, addHist=None): if key not in self._sources.keys(): self.logger.logWARNING( "No source labeled with {0} is booked.".format(key)) return default # Decorators if addHist is not None: self._sources[key]['history'].append(addHist) return self._sources[key]['obj'] def update(self, key, obj=None, addHist=None): if obj is None: self.logger.logWARNING( "Update a 'None' with key '{0}'".format(key)) if key in self._sources.keys(): self.logger.logDEBUG("Overwrite source '{0}'".format(key)) self._sources[key]['obj'] = obj else: self._sources[key] = { 'obj': obj, 'history': [], } if addHist is not None: self._sources[key]['history'].append(addHist) def keys(self): return self._sources.keys()
class CIndexItemTemplate(object): def __init__(self): self.indexInfo = OrderedDict() self.indexInfo[index_ID] = None self.indexInfo[index_Name] = None self.indexInfo[index_OpenPrice] = None self.indexInfo[index_ClosePrice] = None self.indexInfo[index_ClosePrice_Yesterday] = None self.indexInfo[index_HighPrice] = None self.indexInfo[index_LowerPrice] = None self.indexInfo[index_Volumn] = None self.indexInfo[index_Turnover] = None self.indexInfo[index_Volumn_Ratio] = None self.indexInfo[index_ZhangDieFu] = None self.indexInfo[index_MA5] = None self.indexInfo[index_MA10] = None self.indexInfo[index_MA20] = None self.indexInfo[index_MA30] = None self.indexInfo[index_MA60] = None self.indexInfo[index_MA120] = None self.indexInfo[index_MA240] = None #indexs # 1. MACD self.indexInfo[index_MACD] = None #2. BOLL self.indexInfo[index_BOLLUp] = None self.indexInfo[index_BOLLMid] = None self.indexInfo[index_BOLLDown] = None self.indexInfo[index_BOLL_Percent] = None self.indexInfo[index_BOLL_Band_width] = None self.indexInfo[index_CLOSE_TO_BOLLUP] = None self.indexInfo[index_CLOSE_TO_BOLLMID] = None self.indexInfo[index_CLOSE_TO_BOLLDOWN] = None self.indexInfo[index_CLOSE_TO_BOLL_DOWN_TO_UP] = None self.indexInfo[index_DISTANCE_MA_SHORT] = None self.indexInfo[index_DISTANCE_MA_MID] = None self.indexInfo[index_DISTANCE_MA_LONG] = None # # 3.RSI self.indexInfo[index_RSI_6] = None self.indexInfo[index_RSI_12] = None self.indexInfo[index_RSI_24] = None self.indexInfo[index_Type] = None def __str__(self): return self.indexInfo.__str__()
class Graph: def __init__(self): self.nodes = OrderedDict() self.edges = OrderedDict() def add_edge(self, src, dst): if src in self.edges: self.edges[src].append(dst) else: self.edges[src] = [dst] def add_node(self, function_name): self.nodes[function_name] = True def __str__(self): return "edges: " + self.edges.__str__() + ", functions: " + list( self.nodes.keys()).__str__() def toDOT(self): funcs = "" for f in self.nodes.keys(): funcs += f + ';' edges = "" for (key, value) in self.edges.items(): if key == None: key = "Module" for dst in value: edges += " " + key + " -> " + dst + ";\n" tpl_str = """ digraph G { ranksep=.25; edge [arrowsize=.5] node [shape=circle, fontname="ArialNarrow", fontsize=10, fixedsize=true, height=1]; $func_list $edge_list } """ tpl = Template(tpl_str) return tpl.substitute(func_list=funcs, edge_list=edges)
class FileManager(Service): """File manager""" def __init__(self): Service.__init__(self) self._files = OrderedDict() def __str__(self): if self.logger.verbosityLevel == VerbosityLevels.DEBUG: for k, v in self._files.items(): print(k, v) return self._files.__str__() def _endSeq(self): """Close files with LIFO order""" while len(self._files) > 0: key, f = self._files.popitem(last=True) # if hasattr(f, '__exit__'): # f.__exit__() # elif hasattr(f, 'InheritsFrom') and f.InheritsFrom('TObject'): # del f # else: # raise NotImplementedError pass def open(self, key, fname, mode): if not key in self._files.keys(): f = TFile.Open(fname, mode) self._files[key] = f else: f = self._files[key] return f def get(self, key): try: return self._files[key] except KeyError as e: self.logger.logINFO( "No file labeled with {0} is booked.".format(key)) return None def keys(self): return self._files.keys()
class Graph: def __init__(self): self.nodes = OrderedDict() self.edges = OrderedDict() def add_edge(self, src, dst): if src in self.edges: self.edges[src].append(dst) else: self.edges[src] = [dst] def add_node(self, function_name): self.nodes[function_name] = True def __str__(self): return "edges : " + self.edges.__str__() + ", functions : " + list(self.nodes.keys()).__str__() def toDOT(self): # funcs = ';'.join(self.nodes.keys()) funcs = "" for f in self.nodes.keys(): funcs += f + ';' edges = "" for (key, value) in self.edges.items(): for dst in value: edges += " " + key + " -> " + dst + ";\n" tpl_str = """ digraph G { ranksep=.25; edge [arrowsize=.5] node [shape=circle, fontname="ArialNarrow", fontsize=12, fixedsize=true, height=.45]; $func_list $edge_list } """ tpl = Template(tpl_str) return tpl.substitute(func_list=funcs, edge_list=edges)
def filter(cls, data, response): """clear response data, this will suitable for the manipulation object """ url = data.get('url', None) if not url: raise ValueError('url key not in the data: {}'.format(data)) for key, value in data.items(): if isinstance(value, dict): data[key] = OrderedDict(sorted(data[key].items(), key=lambda t: t[0])) ordered_data = OrderedDict(sorted(data.items(), key=lambda t: t[0])) id_key = hashlib.md5((ordered_data.__str__()).encode('utf-8')).hexdigest() logger.info(id_key) if response.status_code not in cls.correct_status: url_request_problem_store.create_or_update(code=response.status_code, data=data, key=id_key, content=response.text) return Response_Data(id_key, data, None) return Response_Data(id_key, data, response.text)
class CStockItemTemplate(object): def __init__(self): self.stockInfo = OrderedDict() self.stockInfo[stock_ID] = None self.stockInfo[stock_Name] = None self.stockInfo[stock_OpenPrice] = None self.stockInfo[stock_ClosePrice] = None self.stockInfo[stock_HighPrice] = None self.stockInfo[stock_LowerPrice] = None self.stockInfo[stock_Volumn] = None self.stockInfo[stock_ZhangDieFu] = None self.stockInfo[stock_MA5] = None self.stockInfo[stock_MA10] = None self.stockInfo[stock_MA20] = None self.stockInfo[stock_MA30] = None self.stockInfo[stock_MA60] = None self.stockInfo[stock_MACD] = None self.stockInfo[stock_BOLLUp] = None self.stockInfo[stock_BOLLMid] = None self.stockInfo[stock_BOLLDown] = None self.stockInfo[stock_K] = None self.stockInfo[stock_D] = None self.stockInfo[stock_J] = None self.stockInfo[stock_ShiZhi] = None self.stockInfo[stock_HangYe] = None self.stockInfo[stock_GaiNian] = None self.stockInfo[stock_Days] = None self.stockInfo[stock_XinTai] = None def initWithDict(self, dict_): for key in dict_: self.stockInfo[key] = dict_[key] def __str__(self, *args, **kwargs): return self.stockInfo.__str__() def getColunmInfo(self): return self.stockInfo.keys() def formatToDict(self): return self.stockInfo def getStockInfo(self): return self.stockInfo def getBanKuai(self): return None def isKeyIn(self, key): return False def isAllKeysIn(self, keys): return False def isOneKeyIn(self, keys): return False def FilterBy(self, stockFilter): return False
class Dictionary(): def __init__(self): self.__dictionary = OrderedDict() def clear(self): self.__dictionary.clear() def get_json(self): return json.dumps(self.__dictionary) def set_item(self, key, value): self.__dictionary.__setitem__(key, value) return self def values(self): return [value for value in self.__dictionary.values().__iter__()] def items(self): return self.__dictionary.items() def copy(self): self.__dictionary def constain(self, key): return key in self.get_list_of_key() def get(self, key): return self.__dictionary.get(key) def clear(self, key, default): self.__dictionary.pop(key, default) def format(self, *args, **kwargs): return self.__dictionary.__format__(*args, **kwargs) def ne(self, *args, **kwargs): return self.__dictionary.__ne__(*args, **kwargs) def repr(self, *args, **kwargs): return self.__dictionary.__repr__(*args, **kwargs) def ge(self, *args, **kwargs): return self.dictionary__ge__(*args, **kwargs) def __sizeof__(self): return self.__dictionary.__sizeof__() def setattr(self, *args, **kwargs): return self.__dictionary.__setattr__(*args, **kwargs) def dir(self): return self.__dictionary.__dir__() def le(self, *args, **kwargs): return self.__dictionary.__le__(*args, **kwargs) def delattr(self, *args, **kwargs): return self.__dictionary.__delattr__(*args, **kwargs) def hash(self, *args, **kwargs): return self.__dictionary.__hash__(*args, **kwargs) def gt(self, *args, **kwargs): return self.__dictionary.__gt__(*args, **kwargs) def eq(self, *args, **kwargs): return self.__dictionary.__eq__(*args, **kwargs) def getattribute(self, *args, **kwargs): return self.__dictionary.__getattribute__(*args, **kwargs) def str(self, *args, **kwargs): return self.__dictionary.__str__(*args, **kwargs) def reduce(self, *args, **kwargs): return self.__dictionary.__reduce__(*args, **kwargs) def reduce_ex(self, *args, **kwargs): return self.__dictionary.__reduce_ex__(*args, **kwargs) def lt(self, *args, **kwargs): return self.__dictionary.__lt__(*args, **kwargs) def keys(self): return self.get_list_of_key() def get_list_of_key(self): return [key for key in self.__dictionary.keys().__iter__()]
class ListofEntities(list): def __init__(self, typ): super(ListofEntities, self).__init__() from collections import OrderedDict self._dict_entities = OrderedDict() self._dict_entities_hash = {} self.typeItems = typ self.type_instance = typ() self.changed = [] def _update_hashes(self): self._dict_entities_hash = { hash(v): v for k, v in self._dict_entities.items() } def __hash__(self): return hash(frozenset(self._dict_entities)) def __str__(self): return self._dict_entities.__str__() def __repr__(self): return self._dict_entities.__repr__() def __unicode__(self): return self.__str__() def __getitem__(self, item): return self._dict_entities.values().__getitem__(item) def update_from_changed_entities(self, changed_entities): if changed_entities is None: return for entity in changed_entities: if hasattr(entity, 'is_tombstone') and entity.is_tombstone: continue try: self._dict_entities[entity.id].update_from_changed_entities( entity) except KeyError: self._dict_entities[entity.id] = entity self._update_hashes() def get(self, entity_id): return self._dict_entities.get(entity_id) def extend(self, objects, track=True): if not all(isinstance(x, self.typeItems) for x in objects): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) for o in objects: self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.extend(objects) def append(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.append(o) def delete(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) if o.id in self._dict_entities: del self._dict_entities[o.id] if hash(o) in self._dict_entities_hash: del self._dict_entities_hash[hash(o)] if track: o.is_tombstone = True self.changed.append(o) def modify(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) if o.id in self._dict_entities: h = hash(self._dict_entities[o.id]) if h in self._dict_entities_hash: del self._dict_entities_hash[h] self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.append(o) def __iter__(self): return self._dict_entities.values().__iter__() def __len__(self): return len(self._dict_entities) def containsduplicate(self, item): if not isinstance(item, self.typeItems): return False else: return item._hash() in self._dict_entities_hash def __contains__(self, item): if not isinstance(item, self.typeItems): return False else: return item.id in self._dict_entities def get_changed_entities(self): return self.changed
class sdictm(object): """ A dictionary which allows accessing it's values using a dot notation. i.e. `d['a']` can be accessed as `d.a` Mutable version """ _INSTANCE_VAR_LIST = ['_data'] def __init__(self, obj): self._data = OrderedDict() assert obj is not None if isinstance(obj, dict): for key, val in obj.items(): if isinstance(val, dict): self._data[key] = self.__class__(val) elif isinstance(val, list): self._data[key] = [] for v in val: if isinstance(v, dict): self._data[key].append(self.__class__(v)) else: self._data[key] = val else: self._data[key] = val else: raise RuntimeError("should be initialized with a dictionary only") assert isinstance(self._data, dict) def __repr__(self): return self._data.__repr__() def __str__(self): return self._data.__str__() def __getattr__(self, attr): if attr == '__getstate__': raise AttributeError() if attr in self._INSTANCE_VAR_LIST: return object.__getattribute__(self, attr) ret = self._data.get(attr) if ret is None: warn("Returning None value for {}".format(attr), stacklevel=2) return ret def __getitem__(self, key): return self.__getattr__(key) def __set__(self, key, value): self._data[key] = value def __setitem__(self, key, value): self.__set__(key, value) def __setattr__(self, attr, value): if attr in self._INSTANCE_VAR_LIST: object.__setattr__(self, attr, value) else: self._data[attr] = value def __iter__(self): return iter(self._data) def get(self, key, default_value): value = self[key] if value is None: return default_value else: return value def keys(self): return self._data.keys() def todict(self): dic_data = OrderedDict() for key, value in self._data.items(): if isinstance(value, sdictm): dic_data[key] = value.todict() elif isinstance(value, list): dic_data[key] = [] for v in value: if isinstance(v, sdictm): dic_data[key].append(v.todict()) else: dic_data[key].append(v) else: dic_data[key] = value return dic_data def copy(self): """ Return a copy of the class. The copy is deep. :return: """ return self.__class__(self.todict()) def update(self, **kwargs): """ Update the dictionary with the values given in the function (only goes one level down) :param kwargs: :return: """ for key, value in kwargs.items(): if key in self._data: logger.debug("Replacing {} with {} for key {}".format( self._data[key], value, key)) else: logger.debug("Adding new key {} with value {}".format( key, value)) self._data[key] = value return self def apply(self, fn): """ Recursively apply fn on all leaf key, value pairs :param fn: :return: """ for key, value in self._data.copy().items(): if isinstance(value, sdictm): value.apply(fn) elif isinstance(value, list): contains_sdictm = False for i, v in enumerate(value): if isinstance(v, sdictm): v.apply(fn) contains_sdictm = True if not contains_sdictm: fn(self._data, key, value) else: fn(self._data, key, value) def frozen(self): return sdict(self.todict())
def __str__(self): outf = OrderedDict() for key in self.keys(): outf[key] = self[key] return outf.__str__()
class KeyMap(unohelper.Base, XRestKeyMap): def __init__(self, **kwargs): self._value = OrderedDict(kwargs) def __len__(self): return len(self._value) def __iter__(self): for value in self._value.values(): yield self._getValue(value) def __getitem__(self, index): return self.getValueByIndex(index) def __add__(self, other): if isinstance(other, type(self)): self._value.update(other._value) return self def __radd__(self, other): return self.__add__(other) def __iadd__(self, other): return self.__add__(other) def __repr__(self): return self._value.__repr__() def __str__(self): return self._value.__str__() def _getValue(self, value): if isinstance(value, dict): value = KeyMap(**value) elif isinstance(value, list): value = tuple(value) return value # XStringKeyMap @property def Count(self): return self.__len__() def getValue(self, key): if key in self._value: value = self._value[key] return self._getValue(value) print( "KeyMap.getValue() Error: %s **************************************" % key) raise NoSuchElementException() def hasValue(self, key): return key in self._value def insertValue(self, key, value): self._value[key] = value def setValue(self, key, value): self._value[key] = value def getKeyByIndex(self, index): if 0 <= index < self.Count: return self._value.keys()[index] raise IndexOutOfBoundsException() def getValueByIndex(self, index): key = self.getKeyByIndex(index) value = self._value[key] return self._getValue(value) # XRestKeyMap def getKeys(self): return tuple(self._value.keys()) def getDefaultValue(self, key, default=None): if key in self._value: value = self._value[key] return self._getValue(value) else: return default def getType(self, key): if self.hasValue(key): value = self._value[key] if isinstance(value, dict): return 'KeyMap' if isinstance(value, (list, tuple)): return 'Enumerator' return 'Value' def isKeyMap(self, key): if self.hasValue(key): value = self._value[key] return isinstance(value, KeyMap) return False def update(self, keymap): for key in keymap.getKeys(): self._value[key] = keymap.getValue(key) def fromJson(self, jsonstr): self._value = json.loads(jsonstr) def fromJsonKey(self, jsonstr, key): self._value[key] = json.loads(jsonstr) def toJson(self): return json.dumps(self._value) def toJsonKey(self, key): return json.dumps(self._value[key])
class ListofEntities(list): def __init__(self, typ): super(ListofEntities, self).__init__() from collections import OrderedDict self._dict_entities = OrderedDict() self._dict_entities_hash = {} self.typeItems = typ self.type_instance = typ() self.changed = [] def _update_hashes(self): self._dict_entities_hash = {hash(v): v for k, v in self._dict_entities.items()} def __hash__(self): return hash(frozenset(self._dict_entities)) def __str__(self): return self._dict_entities.__str__() def __repr__(self): return self._dict_entities.__repr__() def __unicode__(self): return self.__str__() def __getitem__(self, item): return self._dict_entities.values().__getitem__(item) def update_from_changed_entities(self, changed_entities): if changed_entities is None: return for entity in changed_entities: if hasattr(entity, 'is_tombstone') and entity.is_tombstone: continue try: self._dict_entities[entity.id].update_from_changed_entities(entity) except KeyError: self._dict_entities[entity.id] = entity self._update_hashes() def get(self, entity_id): return self._dict_entities.get(entity_id) def extend(self, objects, track=True): if not all(isinstance(x, self.typeItems) for x in objects): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) for o in objects: self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.extend(objects) def append(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.append(o) def delete(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) if o.id in self._dict_entities: del self._dict_entities[o.id] if hash(o) in self._dict_entities_hash: del self._dict_entities_hash[hash(o)] if track: o.is_tombstone = True self.changed.append(o) def modify(self, o, track=True): if not isinstance(o, self.typeItems): raise ValueError('this ListofEntities can only contain %s' % self.typeItems.__name__) if o.id in self._dict_entities: h = hash(self._dict_entities[o.id]) if h in self._dict_entities_hash: del self._dict_entities_hash[h] self._dict_entities[o.id] = o self._dict_entities_hash[hash(o)] = o if track: self.changed.append(o) def __iter__(self): return self._dict_entities.values().__iter__() def __len__(self): return len(self._dict_entities) def containsduplicate(self, item): if not isinstance(item, self.typeItems): return False else: return item._hash() in self._dict_entities_hash def __contains__(self, item): if not isinstance(item, self.typeItems): return False else: return item.id in self._dict_entities def get_changed_entities(self): return self.changed
def __str__(self): return "*%s*" % ordered_dict.__str__(self)
def order(self, keyword, para_data): try: if self.request.method == 'POST': if keyword == "add": today = datetime.now() order_no = get_sale_order_no(today) para_data["orderNo"] = order_no para_data["createdTime"] = today print(keyword) try: car_user = para_data.get("carUser") user_id = para_data.get("userId") worker_id = para_data.get("workerId") pc_id = para_data.get("pcId") car_phone = para_data.get("carPhone") car_model = para_data.get("carModel") car_id = para_data.get("carId") pc_sign = para_data.get("pcSign") worker_name = para_data.get("workerName") order_check_id = get_uuid1() save_data = { 'createdTime': para_data.get("createdTime").strftime( "%Y-%m-%d %H:%M:%S"), 'userId': user_id, 'pcId': pc_id, 'pcSign': pc_sign, 'carId': car_id, 'workerName': worker_name, 'workerId': worker_id, 'carUser': car_user, 'carPhone': car_phone, 'carModel': car_model, "orderNo": order_no, "orderCheckId": order_check_id, 'code': config.get_local_register_code(), } parameter = para_data.get("parameter", []) if type(parameter) == str: parameter = json.loads(parameter) page = 0 for data in parameter: page += 1 order_id = get_uuid1() services = data.get('project') services = services.split('-') first_service_name = services[0] second_service_name = services[1] first_service_id = service_handler.get_service_id_by_name( first_service_name)[0] second_service_id = service_handler.get_service_id_by_name( second_service_name, first_service_id)[0] attributes = data.get('attribute') logger.info(attributes) try: unit = attributes.get('单位', '') unit_price = float(attributes.get('单价', '')) number = int(attributes.get('数量', '')) subtotal = float(attributes.get('小计', '')) total = float(attributes.get('总价', '')) note = attributes.get('备注', '') model = attributes.get('型号', '') brand = attributes.get('品牌', '') except Exception as attribute_deal_error: logger.error(attribute_deal_error) unit = '' unit_price = 0.0 number = 0 subtotal = 0.0 total = 0.0 note = '' model = '' brand = '' temp = { 'project': data.get('project'), 'id': order_id, 'attribute': json.dumps(attributes, ensure_ascii=False), 'serviceId': second_service_id, 'unit': unit, 'unit_price': unit_price, 'number': number, 'subtotal': subtotal, 'total': total, 'note': note } db_transaction_util.begin() logger.info('增加销售数据') logger.info(temp.__str__()) logger.info(save_data.__str__()) sale_id = sale_handler.add_sale_info( dict(temp, **save_data)) service_attributes = service_handler.get_attribute_by_service( second_service_id) all_required_attr = attribute_handler.get_all_required_attributes( ) required_attr_list = [] for attr in all_required_attr: required_attr_list.append(attr[1]) logger.info('增加销售扩展属性') for srv_attr in service_attributes: attr_name = srv_attr[1] if attr_name not in required_attr_list: attr_id = attribute_handler.get_attr_by_name( attr_name)[0] sale_item_handler.add_sale_item( sale_id, attr_id, attributes.get(attr_name, '')) # 库存信息更新 logger.info('更新库存信息') stock_service.refresh_stock_info( sale_id, brand, model, number, unit, second_service_id) # 回访设置 if data.get("callbackTime"): logger.info('增加回访信息') customer_handler.add_return_visit_data( data.get("callbackTime"), car_phone, car_id, car_user, today) db_transaction_util.commit() except Exception as add_error: logger.error(add_error) logger.error('traceback.format_exc():\n{}'.format( traceback.format_exc())) db_transaction_util.rollback() raise ApiException(ErrorCode.ParameterMiss) try: p = "defaultPrinter" # 打印机名称 html, page_height = self.preview_html(para_data, True) logger.info('\n' + html) Printer.printing(p, html, page_height) except: pass return set_return_dicts({"orderNo": order_no}) elif keyword == 'preview': html = self.preview_html(para_data) logger.info('\n' + html) return set_return_dicts(html) else: raise ApiException(ErrorCode.ErrorRequest) elif self.request.method == "GET": if not self.storeId: raise ApiException(ErrorCode.PCError) if keyword == "detail": check_order_id = para_data.get("checkOrderId") if not check_order_id: raise ApiException(ErrorCode.ParameterMiss) if self.connect: result_dict = SocketServer("orderdetail {} {}".format( self.storeId, check_order_id)) else: result = get_sale_info_by_one_key( "orderCheckId", check_order_id) result_list = list() result_dict = {} if result: created_time = '' car_id = '' car_user = '' car_phone = '' car_model = '' total_price = 0 order_no = '' for data in result: attribute = OrderedDict() for attr in sale_item_handler.get_item_info_buy_sale_id( data['sale_id']): attribute[ attr['name']] = attr['attribute_value'] logger.info('销售数据属性调整后的记录:' + attribute.__str__()) created_time = data['createdTime'] car_id = data['carId'] car_user = data['carUser'] car_phone = data['carPhone'] car_model = data['carModel'] price = data['unit_price'] pc_id = data['pcId'] order_no = data['orderNo'] if pc_id: total_price += price attribute['project'] = data['project'] attribute['totalPrice'] = price attribute['orderNo'] = order_no result_list.append(attribute) try: pc_sign = config.get_store_name() except: pc_sign = "" result_dict = { "msg": result_list, "totalPrice": total_price, "createdTime": created_time, "carId": car_id, "carUser": car_user, "carPhone": car_phone, "carModel": car_model, "orderNo": order_no, "checkOrderId": check_order_id, "pcSign": pc_sign, } if result_dict == 'restart': raise ApiException(ErrorCode.ReStartPC) return set_return_dicts(result_dict) else: raise ApiException(ErrorCode.ErrorRequest) except ApiException as e: return set_return_dicts(forWorker=e.error_result['forWorker'], code=e.error_result['errorCode'], forUser=e.error_result['forUser'])
def __str__(self): return self.name + "_" + OrderedDict.__str__(self)
# Order dictionalry is a dictionary subclass which remembers the orders in which the orders were done from collections import OrderedDict d = OrderedDict() d[1] = 'e' d[2] = 'd' d[3] = 'u' d[4] = 'r' d[5] = 'e' d[6] = 'k' d[7] = 'a' print(d) print(d.keys()) print(d.items()) print(d.__len__()) print(d.__str__()) print('&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&') print(d) d[1] = 'p' print(d)