Exemplo n.º 1
0
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
Exemplo n.º 2
0
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__()
Exemplo n.º 3
0
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__()
Exemplo n.º 4
0
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__())
Exemplo n.º 5
0
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__())
Exemplo n.º 6
0
    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__()
Exemplo n.º 7
0
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()
Exemplo n.º 8
0
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__()
Exemplo n.º 9
0
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)
Exemplo n.º 10
0
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()
Exemplo n.º 11
0
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)
Exemplo n.º 12
0
    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)
Exemplo n.º 13
0
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
Exemplo n.º 14
0
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__()]
Exemplo n.º 15
0
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
Exemplo n.º 16
0
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())
Exemplo n.º 17
0
 def __str__(self):
     outf = OrderedDict()
     for key in self.keys():
         outf[key] = self[key]
     return outf.__str__()
Exemplo n.º 18
0
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__()]
Exemplo n.º 19
0
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])
Exemplo n.º 20
0
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
Exemplo n.º 21
0
 def __str__(self):
     return "*%s*" % ordered_dict.__str__(self)
Exemplo n.º 22
0
    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'])
Exemplo n.º 23
0
 def __str__(self):
     return self.name + "_" + OrderedDict.__str__(self)
Exemplo n.º 24
0
# 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)