def get_fields(self, serialize, obj=None, data=None, nested=False): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by default_fields(). """ ret = SortedDict() # Get the explicitly declared fields for key, field in self.fields.items(): ret[key] = field # Set up the field field.initialize(parent=self) # Add in the default fields fields = self.default_fields(serialize, obj, data, nested) for key, val in fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): ret[key] = field # Set up the field field.initialize(parent=self, field_name=key) # Add in the default fields default_fields = self.get_default_fields() for key, val in default_fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): ret[key] = field # Set up the field field.initialize(parent=self, field_name=key) # Add in the default fields default_fields = self.get_default_fields() for key, val in default_fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def _com_to_dict(com): """ convert committee into a suitable dict for output """ od = SortedDict(_fdict(com.__dict__)) od.pop('parent_id') if '_state' in od: od.pop('_state') return od
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): ret[key] = field # Add in the default fields default_fields = self.get_default_fields() for key, val in default_fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: assert isinstance( self.opts.fields, (list, tuple)), '`fields` must be a list or tuple' new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: assert isinstance( self.opts.exclude, (list, tuple)), '`exclude` must be a list or tuple' for key in self.opts.exclude: ret.pop(key, None) # Mark immutable fields as read-only if there was an object instance provided if self.object: # Ensure that 'immutable_fields' is an iterable assert isinstance( self.opts.immutable_fields, (list, tuple)), '`immutable_fields` must be a list or tuple' # Set the `read_only` flag to any fields that have been specified # in the `immutable_fields` option for field_name in self.opts.immutable_fields: assert field_name in ret, ( "Non-existant field '%s' specified in `immutable_fields` " "on serializer '%s'." % (field_name, self.__class__.__name__)) ret[field_name].read_only = True for key, field in ret.items(): field.initialize(parent=self, field_name=key) return ret
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): if isinstance(field, HALLinkField): self.add_field_to_links(key, field) else: ret[key] = field # Add in the default fields default_fields = self.get_default_fields(ret) for key, val in default_fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: assert isinstance(self.opts.fields, (list, tuple)), '`fields` must be a list or tuple' new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: assert isinstance(self.opts.exclude, (list, tuple)), '`exclude` must be a list or tuple' for key in self.opts.exclude: ret.pop(key, None) self.additional_links.pop(key, None) self.embedded_fields.pop(key, None) # additional embedded fields if getattr(self.opts, 'additional_embedded', None): assert isinstance(self.opts.additional_embedded, (list, tuple)), '`exclude` must be a list or tuple' for key in self.opts.additional_embedded: field = ret.pop(key, None) if field: self.add_field_to_embedded(key, field) for key, field in ret.items(): field.initialize(parent=self, field_name=key) return ret
class QualityOfService(object): def __init__(self, backend, resource, prefetch_count=None, interval=None): self.backend = backend self.resource = resource self.prefetch_count = prefetch_count self.interval = interval self._delivered = SortedDict() self._restored_once = False atexit.register(self.restore_unacked_once) def can_consume(self): return len(self._delivered) > self.prefetch_count def append(self, message, queue_name, delivery_tag): self._delivered[delivery_tag] = message, queue_name def ack(self, delivery_tag): self._delivered.pop(delivery_tag, None) def restore_unacked(self): for delivery_tag, delivered in self._delivered.items(): message, queue_name = delivered send = self.backend.prepare_message(message.body, 2, 10, message.content_type, message.content_encoding) send["destination"] = queue_name self.resource.put(queue_name, serialize(send)) self._delivered = SortedDict() def requeue(self, delivery_tag): try: message, queue_name = self._delivered.pop(delivery_tag) except KeyError: pass self.resource.put(queue_name, message) def restore_unacked_once(self): if not self._restored_once: if self._delivered: sys.stderr.write( "Restoring unacknowledged messages: %s\n" % ( self._delivered)) self.restore_unacked() if self._delivered: sys.stderr.write("UNRESTORED MESSAGES: %s\n" % ( self._delivered))
def get_model_order(model_lists): model_adj = SortedDict() for model in model_lists: model_adj[ model ] = get_related_models(model) order = filter(lambda m: not bool(model_adj[m]), model_adj.keys()) map(lambda m: model_adj.pop(m), order) while model_adj: for model in model_adj: deps = model_adj[model] if model in deps: #Es recursivo deps.remove(model) if all(map(lambda d: d not in model_adj, deps)): order.append(model) model_adj.pop(model) return order
def breadcrumbs_add(request, ctx): bc = request.session.get('bc', SortedDict()) title = ctx.get('title', '') if not title: # Não tem title definido, tenta montar baseado na URL path_splited = request.path.split('/') path_splited.reverse() for i in path_splited: if i and not i.isdigit(): title = i.replace('_', ' ').capitalize() break if request.path == '/': bc = SortedDict() if title in bc: # Removendo itens após o ``title`` encontrado title_index = bc.keyOrder.index(title) for key in bc.keyOrder[title_index + 1:]: bc.pop(key) bc[title] = request.get_full_path() request.session['bc'] = bc ctx['breadcrumbs'] = bc
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): ret[key] = field # Add in the default fields default_fields = self.get_default_fields() for key, val in default_fields.items(): if key not in ret: ret[key] = val # If "fields" is specified, use those fields, in that order. if self.opts.fields: assert isinstance( self.opts.fields, (list, tuple)), "`fields` must be a list or tuple" new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in "exclude" if self.opts.exclude: assert isinstance( self.opts.exclude, (list, tuple)), "`exclude` must be a list or tuple" for key in self.opts.exclude: ret.pop(key, None) for key, field in ret.items(): field.initialize(parent=self, field_name=key) return ret
def get_fields(self, serialize, obj=None, data=None, nested=False): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields for key, field in self.fields.items(): ret[key] = field # Determine if the declared field corrosponds to a model field. try: if key == 'pk': model_field = obj._meta.pk else: model_field = obj._meta.get_field_by_name(key)[0] except: model_field = None # Set up the field field.initialize(parent=self, model_field=model_field) # Add in the default fields fields = self.default_fields(serialize, obj, data, nested) for key, val in fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def get_fields(self, serialize, obj=None, data=None, nested=False): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields for key, field in self.fields.items(): ret[key] = field # Determine if the declared field corrosponds to a model field. try: if key == 'pk': model_field = obj._meta.pk else: model_field = obj._meta.get_field_by_name(key)[0] except: model_field = None # Set up the field field.initialize(parent=self, model_field=model_field) # Add in the default fields fields = self.default_fields(serialize, obj, data, nested) for key, val in fields.items(): if key not in ret: ret[key] = val # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def extract_params(params, prefix='turbion.'): """Extracts additional request params and checks signature""" params = SortedDict( [(name[len(prefix):], value)\ for name, value in params.iteritems() if name.startswith(prefix)] ) signature = params.pop('signature', '') if signature != _sign(params): raise ValueError('Parameters signature doesn\'t match') return params
def get_fields(self): """ Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields(). """ ret = SortedDict() # Get the explicitly declared fields base_fields = copy.deepcopy(self.base_fields) for key, field in base_fields.items(): ret[key] = field # Add in the default fields default_fields = self.get_default_fields() for key, val in default_fields.items(): if key not in ret: ret[key] = val # If "fields" is specified, use those fields, in that order. if self.opts.fields: assert isinstance(self.opts.fields, (list, tuple)), "`fields` must be a list or tuple" new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in "exclude" if self.opts.exclude: assert isinstance(self.opts.exclude, (list, tuple)), "`exclude` must be a list or tuple" for key in self.opts.exclude: ret.pop(key, None) for key, field in ret.items(): field.initialize(parent=self, field_name=key) return ret
def from_querydict(cls, image_or_storage_path, querydict, secure=False): kwargs = SortedDict() for verbose, short in six.iteritems(cls.query_map): if short in querydict: kwargs[verbose] = querydict[short] if 'security' in kwargs: if not cls.check_security_hash(kwargs.pop('security'), kwargs): raise ValueError("Security check failed.") elif secure: raise ValueError("Security hash missing.") adjustments = cls._deserialize_requested(kwargs['requested']) return cls([image_or_storage_path], adjustments)
def get_checking_fields(self, special_exclude=['id']): """ Returns the set of fields on which we perform checkings """ ret = SortedDict() for f in self._meta.fields: # avoid special_exclude fields if f.attname in special_exclude: continue ret[f.attname] = f # Deal with reverse relationships reverse_rels = self._meta.get_all_related_objects() # reverse_rels += self._meta.get_all_related_many_to_many_objects() for relation in reverse_rels: accessor_name = relation.get_accessor_name() to_many = relation.field.rel.multiple if not self.opts.fields or accessor_name not in self.opts.fields: continue if not to_many: raise NotImplementedError ret[accessor_name] = PrimaryKeyRelatedField() # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def from_querydict(cls, image_or_storage_path, querydict, secure=False): kwargs = SortedDict() for verbose, short in cls.param_map.iteritems(): try: value = querydict[short] except KeyError: continue if verbose in cls.int_params: # Raises ValueError if it can't be converted. value = int(value) kwargs[verbose] = value if 'security' in kwargs: if not cls.check_security_hash(kwargs.pop('security'), kwargs): raise ValueError("Security check failed.") elif secure: raise ValueError("Security hash missing.") return cls(image_or_storage_path, **kwargs)
def from_querydict(cls, image_or_storage_path, querydict, secure=False, generate=False): kwargs = SortedDict() for verbose, short in six.iteritems(cls.query_map): if short in querydict: kwargs[verbose] = querydict[short] if 'security' in kwargs: if not cls.check_security_hash(kwargs.pop('security'), kwargs): raise ValueError("Security check failed.") elif secure: raise ValueError("Security hash missing.") adjustments = cls._deserialize_requested(kwargs['requested']) helper = cls([image_or_storage_path], generate=generate) for adjustment in adjustments: helper.adjust(adjustment) return helper
def before(self, api, kwargs=None, **extra): """Formats given keyword arguments in MetaTrader format. <command>-arg1=val1|arg2=val2|... """ # Thanks to the bug in NEWACCOUNT, we are forced to use # SortedDict. def ensure_unicode(string): if isinstance(string, str): return string.decode('cp1251') return unicode(string) kwargs = SortedDict(kwargs or {}) kwargs.update(extra) key = kwargs.pop("key", None) if self.encoded and not key: raise MT4Error("Key required to call %r" % self) qs = u"%s-%s" % (self.command.upper(), u"|".join(u"{}={}".format(*map(ensure_unicode, pair)) for pair in kwargs.iteritems())) return (qs, ), {"key": key, "sensitive_fields_regexp": getattr(self, "sensitive_fields_regexp", None)}
class SortedDictTests(SimpleTestCase): def setUp(self): self.d1 = SortedDict() self.d1[7] = 'seven' self.d1[1] = 'one' self.d1[9] = 'nine' self.d2 = SortedDict() self.d2[1] = 'one' self.d2[9] = 'nine' self.d2[0] = 'nil' self.d2[7] = 'seven' def test_basic_methods(self): self.assertEqual(self.d1.keys(), [7, 1, 9]) self.assertEqual(self.d1.values(), ['seven', 'one', 'nine']) self.assertEqual(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')]) def test_overwrite_ordering(self): """ Overwriting an item keeps it's place. """ self.d1[1] = 'ONE' self.assertEqual(self.d1.values(), ['seven', 'ONE', 'nine']) def test_append_items(self): """ New items go to the end. """ self.d1[0] = 'nil' self.assertEqual(self.d1.keys(), [7, 1, 9, 0]) def test_delete_and_insert(self): """ Deleting an item, then inserting the same key again will place it at the end. """ del self.d2[7] self.assertEqual(self.d2.keys(), [1, 9, 0]) self.d2[7] = 'lucky number 7' self.assertEqual(self.d2.keys(), [1, 9, 0, 7]) def test_change_keys(self): """ Changing the keys won't do anything, it's only a copy of the keys dict. """ k = self.d2.keys() k.remove(9) self.assertEqual(self.d2.keys(), [1, 9, 0, 7]) def test_init_keys(self): """ Initialising a SortedDict with two keys will just take the first one. A real dict will actually take the second value so we will too, but we'll keep the ordering from the first key found. """ tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) d = SortedDict(tuples) self.assertEqual(d.keys(), [2, 1]) real_dict = dict(tuples) self.assertEqual(sorted(real_dict.values()), ['one', 'second-two']) # Here the order of SortedDict values *is* what we are testing self.assertEqual(d.values(), ['second-two', 'one']) def test_overwrite(self): self.d1[1] = 'not one' self.assertEqual(self.d1[1], 'not one') self.assertEqual(self.d1.keys(), self.d1.copy().keys()) def test_append(self): self.d1[13] = 'thirteen' self.assertEqual( repr(self.d1), "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}" ) def test_pop(self): self.assertEqual(self.d1.pop(1, 'missing'), 'one') self.assertEqual(self.d1.pop(1, 'missing'), 'missing') # We don't know which item will be popped in popitem(), so we'll # just check that the number of keys has decreased. l = len(self.d1) self.d1.popitem() self.assertEqual(l - len(self.d1), 1) def test_dict_equality(self): d = SortedDict((i, i) for i in xrange(3)) self.assertEqual(d, {0: 0, 1: 1, 2: 2}) def test_tuple_init(self): d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") def test_pickle(self): self.assertEqual( pickle.loads(pickle.dumps(self.d1, 2)), {7: 'seven', 1: 'one', 9: 'nine'} ) def test_clear(self): self.d1.clear() self.assertEqual(self.d1, {}) self.assertEqual(self.d1.keyOrder, [])
class SortedDictTests(SimpleTestCase): def setUp(self): self.d1 = SortedDict() self.d1[7] = 'seven' self.d1[1] = 'one' self.d1[9] = 'nine' self.d2 = SortedDict() self.d2[1] = 'one' self.d2[9] = 'nine' self.d2[0] = 'nil' self.d2[7] = 'seven' def test_basic_methods(self): self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9]) self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'one', 'nine']) self.assertEqual(list(six.iteritems(self.d1)), [(7, 'seven'), (1, 'one'), (9, 'nine')]) def test_overwrite_ordering(self): """ Overwriting an item keeps its place. """ self.d1[1] = 'ONE' self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'ONE', 'nine']) def test_append_items(self): """ New items go to the end. """ self.d1[0] = 'nil' self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9, 0]) def test_delete_and_insert(self): """ Deleting an item, then inserting the same key again will place it at the end. """ del self.d2[7] self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0]) self.d2[7] = 'lucky number 7' self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0, 7]) if six.PY2: def test_change_keys(self): """ Changing the keys won't do anything, it's only a copy of the keys dict. This test doesn't make sense under Python 3 because keys is an iterator. """ k = self.d2.keys() k.remove(9) self.assertEqual(self.d2.keys(), [1, 9, 0, 7]) def test_init_keys(self): """ Initialising a SortedDict with two keys will just take the first one. A real dict will actually take the second value so we will too, but we'll keep the ordering from the first key found. """ tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) d = SortedDict(tuples) self.assertEqual(list(six.iterkeys(d)), [2, 1]) real_dict = dict(tuples) self.assertEqual(sorted(six.itervalues(real_dict)), ['one', 'second-two']) # Here the order of SortedDict values *is* what we are testing self.assertEqual(list(six.itervalues(d)), ['second-two', 'one']) def test_overwrite(self): self.d1[1] = 'not one' self.assertEqual(self.d1[1], 'not one') self.assertEqual(list(six.iterkeys(self.d1)), list(six.iterkeys(self.d1.copy()))) def test_append(self): self.d1[13] = 'thirteen' self.assertEqual( repr(self.d1), "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}" ) def test_pop(self): self.assertEqual(self.d1.pop(1, 'missing'), 'one') self.assertEqual(self.d1.pop(1, 'missing'), 'missing') # We don't know which item will be popped in popitem(), so we'll # just check that the number of keys has decreased. l = len(self.d1) self.d1.popitem() self.assertEqual(l - len(self.d1), 1) def test_dict_equality(self): d = SortedDict((i, i) for i in range(3)) self.assertEqual(d, {0: 0, 1: 1, 2: 2}) def test_tuple_init(self): d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") def test_pickle(self): self.assertEqual( pickle.loads(pickle.dumps(self.d1, 2)), {7: 'seven', 1: 'one', 9: 'nine'} ) def test_copy(self): orig = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) copied = copy.copy(orig) self.assertEqual(list(six.iterkeys(orig)), [1, 0, 2]) self.assertEqual(list(six.iterkeys(copied)), [1, 0, 2]) def test_clear(self): self.d1.clear() self.assertEqual(self.d1, {}) self.assertEqual(self.d1.keyOrder, []) def test_reversed(self): self.assertEqual(list(self.d1), [7, 1, 9]) self.assertEqual(list(self.d2), [1, 9, 0, 7]) self.assertEqual(list(reversed(self.d1)), [9, 1, 7]) self.assertEqual(list(reversed(self.d2)), [7, 0, 9, 1]) def test_insert(self): d = SortedDict() with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") d.insert(0, "hello", "world") assert w[0].category is DeprecationWarning def test_value_for_index(self): d = SortedDict({"a": 3}) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.assertEqual(d.value_for_index(0), 3) assert w[0].category is DeprecationWarning
class SortedDictTests(IgnoreDeprecationWarningsMixin, SimpleTestCase): def setUp(self): super(SortedDictTests, self).setUp() self.d1 = SortedDict() self.d1[7] = 'seven' self.d1[1] = 'one' self.d1[9] = 'nine' self.d2 = SortedDict() self.d2[1] = 'one' self.d2[9] = 'nine' self.d2[0] = 'nil' self.d2[7] = 'seven' def test_basic_methods(self): self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9]) self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'one', 'nine']) self.assertEqual(list(six.iteritems(self.d1)), [(7, 'seven'), (1, 'one'), (9, 'nine')]) def test_overwrite_ordering(self): """ Overwriting an item keeps its place. """ self.d1[1] = 'ONE' self.assertEqual(list(six.itervalues(self.d1)), ['seven', 'ONE', 'nine']) def test_append_items(self): """ New items go to the end. """ self.d1[0] = 'nil' self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9, 0]) def test_delete_and_insert(self): """ Deleting an item, then inserting the same key again will place it at the end. """ del self.d2[7] self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0]) self.d2[7] = 'lucky number 7' self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0, 7]) if six.PY2: def test_change_keys(self): """ Changing the keys won't do anything, it's only a copy of the keys dict. This test doesn't make sense under Python 3 because keys is an iterator. """ k = self.d2.keys() k.remove(9) self.assertEqual(self.d2.keys(), [1, 9, 0, 7]) def test_init_keys(self): """ Initialising a SortedDict with two keys will just take the first one. A real dict will actually take the second value so we will too, but we'll keep the ordering from the first key found. """ tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) d = SortedDict(tuples) self.assertEqual(list(six.iterkeys(d)), [2, 1]) real_dict = dict(tuples) self.assertEqual(sorted(six.itervalues(real_dict)), ['one', 'second-two']) # Here the order of SortedDict values *is* what we are testing self.assertEqual(list(six.itervalues(d)), ['second-two', 'one']) def test_overwrite(self): self.d1[1] = 'not one' self.assertEqual(self.d1[1], 'not one') self.assertEqual(list(six.iterkeys(self.d1)), list(six.iterkeys(self.d1.copy()))) def test_append(self): self.d1[13] = 'thirteen' self.assertEqual(repr(self.d1), "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}") def test_pop(self): self.assertEqual(self.d1.pop(1, 'missing'), 'one') self.assertEqual(self.d1.pop(1, 'missing'), 'missing') # We don't know which item will be popped in popitem(), so we'll # just check that the number of keys has decreased. l = len(self.d1) self.d1.popitem() self.assertEqual(l - len(self.d1), 1) def test_dict_equality(self): d = SortedDict((i, i) for i in range(3)) self.assertEqual(d, {0: 0, 1: 1, 2: 2}) def test_tuple_init(self): d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") def test_pickle(self): self.assertEqual(pickle.loads(pickle.dumps(self.d1, 2)), { 7: 'seven', 1: 'one', 9: 'nine' }) def test_copy(self): orig = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) copied = copy.copy(orig) self.assertEqual(list(six.iterkeys(orig)), [1, 0, 2]) self.assertEqual(list(six.iterkeys(copied)), [1, 0, 2]) def test_clear(self): self.d1.clear() self.assertEqual(self.d1, {}) self.assertEqual(self.d1.keyOrder, []) def test_reversed(self): self.assertEqual(list(self.d1), [7, 1, 9]) self.assertEqual(list(self.d2), [1, 9, 0, 7]) self.assertEqual(list(reversed(self.d1)), [9, 1, 7]) self.assertEqual(list(reversed(self.d2)), [7, 0, 9, 1])
class SortedDictTests(SimpleTestCase): def setUp(self): super(SortedDictTests, self).setUp() self.d1 = SortedDict() self.d1[7] = "seven" self.d1[1] = "one" self.d1[9] = "nine" self.d2 = SortedDict() self.d2[1] = "one" self.d2[9] = "nine" self.d2[0] = "nil" self.d2[7] = "seven" def test_basic_methods(self): self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9]) self.assertEqual(list(six.itervalues(self.d1)), ["seven", "one", "nine"]) self.assertEqual(list(six.iteritems(self.d1)), [(7, "seven"), (1, "one"), (9, "nine")]) def test_overwrite_ordering(self): """ Overwriting an item keeps its place. """ self.d1[1] = "ONE" self.assertEqual(list(six.itervalues(self.d1)), ["seven", "ONE", "nine"]) def test_append_items(self): """ New items go to the end. """ self.d1[0] = "nil" self.assertEqual(list(six.iterkeys(self.d1)), [7, 1, 9, 0]) def test_delete_and_insert(self): """ Deleting an item, then inserting the same key again will place it at the end. """ del self.d2[7] self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0]) self.d2[7] = "lucky number 7" self.assertEqual(list(six.iterkeys(self.d2)), [1, 9, 0, 7]) if six.PY2: def test_change_keys(self): """ Changing the keys won't do anything, it's only a copy of the keys dict. This test doesn't make sense under Python 3 because keys is an iterator. """ k = self.d2.keys() k.remove(9) self.assertEqual(self.d2.keys(), [1, 9, 0, 7]) def test_init_keys(self): """ Initialising a SortedDict with two keys will just take the first one. A real dict will actually take the second value so we will too, but we'll keep the ordering from the first key found. """ tuples = ((2, "two"), (1, "one"), (2, "second-two")) d = SortedDict(tuples) self.assertEqual(list(six.iterkeys(d)), [2, 1]) real_dict = dict(tuples) self.assertEqual(sorted(six.itervalues(real_dict)), ["one", "second-two"]) # Here the order of SortedDict values *is* what we are testing self.assertEqual(list(six.itervalues(d)), ["second-two", "one"]) def test_overwrite(self): self.d1[1] = "not one" self.assertEqual(self.d1[1], "not one") self.assertEqual(list(six.iterkeys(self.d1)), list(six.iterkeys(self.d1.copy()))) def test_append(self): self.d1[13] = "thirteen" self.assertEqual(repr(self.d1), "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}") def test_pop(self): self.assertEqual(self.d1.pop(1, "missing"), "one") self.assertEqual(self.d1.pop(1, "missing"), "missing") # We don't know which item will be popped in popitem(), so we'll # just check that the number of keys has decreased. l = len(self.d1) self.d1.popitem() self.assertEqual(l - len(self.d1), 1) def test_dict_equality(self): d = SortedDict((i, i) for i in range(3)) self.assertEqual(d, {0: 0, 1: 1, 2: 2}) def test_tuple_init(self): d = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}") def test_pickle(self): self.assertEqual(pickle.loads(pickle.dumps(self.d1, 2)), {7: "seven", 1: "one", 9: "nine"}) def test_copy(self): orig = SortedDict(((1, "one"), (0, "zero"), (2, "two"))) copied = copy.copy(orig) self.assertEqual(list(six.iterkeys(orig)), [1, 0, 2]) self.assertEqual(list(six.iterkeys(copied)), [1, 0, 2]) def test_clear(self): self.d1.clear() self.assertEqual(self.d1, {}) self.assertEqual(self.d1.keyOrder, []) def test_reversed(self): self.assertEqual(list(self.d1), [7, 1, 9]) self.assertEqual(list(self.d2), [1, 9, 0, 7]) self.assertEqual(list(reversed(self.d1)), [9, 1, 7]) self.assertEqual(list(reversed(self.d2)), [7, 0, 9, 1])
class Chart(object): BASE = "http://chart.apis.google.com/chart" defaults = { "chs": "200x200", "cht": "lc" } def __init__(self): # Use a SortedDict for the options so they are added in a # deterministic manner; this eases things like dealing with cache keys # or writing unit tests. self.options = SortedDict() self.datasets = [] self.hidden_datasets = [] self.axes = [] self.datarange = None self.alt = None def clone(self): clone = self.__class__() clone.options = self.options.copy() clone.datasets = self.datasets[:] clone.hidden_datasets = self.hidden_datasets[:] clone.axes = self.axes[:] return clone def img(self, color_override = None): orig_colors = self.options.get('chco') # If color_override is set, replace the chco option with this color if color_override is not None: final_color = [] for c in self.options['chco'].split(','): if c == color_override: c = orig_colors.split(',')[0] else: c = _chart_inactive_color final_color.append(c) self.options['chco'] = ','.join(final_color) url = self.url() if orig_colors: self.options['chco'] = orig_colors width, height = self.options["chs"].split("x") if self.alt: alt = '%s' % escape(self.alt) else: alt = '' s = mark_safe('<img src="%s" width="%s" height="%s" alt="%s" />' % (escape(url), width, height, alt)) return s def url(self): if self.options.get('cht', None) == 't': self.datasets.append(self.options.pop("_mapdata")) # Figure out the chart's data range if not self.datarange: maxvalue = max(max(d) for d in chain(self.datasets, self.hidden_datasets) if d) minvalue = min(min(d) for d in chain(self.datasets, self.hidden_datasets) if d) self.datarange = (minvalue, maxvalue) # Encode data if "chds" in self.options or self.options.get('cht', None) == 'gom': # text encoding if scaling provided, or for google-o-meter type data = "|".join(encode_text(d) for d in chain(self.datasets, self.hidden_datasets)) encoded_data = "t%d:%s" % (len(self.datasets), data) else: # extended encoding otherwise data = extended_separator.join(encode_extended(d, self.datarange) for d in chain(self.datasets, self.hidden_datasets)) encoded_data = "e%d:%s" % (len(self.datasets), data) # Update defaults for k in self.defaults: if k not in self.options: self.options[k] = self.defaults[k] # Start to calculate the URL url = "%s?%s&chd=%s" % (self.BASE, urlencode(self.options), encoded_data) # Calculate axis options if self.axes: axis_options = SortedDict() axis_sides = [] for i, axis in enumerate(self.axes): axis_sides.append(axis.side) for opt in axis.options: try: axis_options.setdefault(opt, []).append(axis.options[opt] % i) except TypeError: pass # Turn the option lists into strings axis_sides = smart_join(",", *axis_sides) for opt in axis_options: axis_options[opt] = smart_join("|", *axis_options[opt]) url += "&chxt=%s&%s" % (axis_sides, urlencode(axis_options)) return url def charts(self): res = [] count = 1 for o in self.options['_final_color_map'].items(): res.append({ 'id': count, 'color': o[0], 'label': o[1], 'img': self.img(color_override=o[0]) }) count += 1 return res
class Chart(object): BASE = "http://chart.apis.google.com/chart" defaults = { "chs": "200x200", "cht": "lc" } def __init__(self): # Use a SortedDict for the opeions so they are added in a # deterministic manner; this eases things like dealing with cache keys # or writing unit tests. self.options = SortedDict() self.datasets = [] self.axes = [] self.datarange = None self.alt = None self.grid_lines = False def clone(self): clone = self.__class__() clone.options = self.options.copy() clone.datasets = self.datasets[:] clone.axes = self.axes[:] return clone def img(self): url = self.url() width, height = self.options["chs"].split("x") if self.alt: alt = 'alt="%s" ' % escape(self.alt) else: alt = '' s = mark_safe('<img src="%s" width="%s" height="%s" %s/>' % (escape(url), width, height, alt)) return s def url(self): if self.options.get('cht', None) == 't': self.datasets.append(self.options.pop("_mapdata")) # Figure out the chart's data range if not self.datarange: maxvalue = max(max(d) for d in self.datasets if d) minvalue = min(min(d) for d in self.datasets if d) self.datarange = (minvalue, maxvalue) # Encode data if "chds" in self.options or self.options.get('cht', None) == 'gom': # text encoding if scaling provided, or for google-o-meter type data = "|".join(encode_text(d) for d in self.datasets) if self.grid_lines: encoded_data = "t1:%s" % data else: encoded_data = "t:%s" % data else: # extended encoding otherwise data = extended_separator.join(encode_extended(d, self.datarange) for d in self.datasets) encoded_data = "e:%s" % data # Update defaults for k in self.defaults: if k not in self.options: self.options[k] = self.defaults[k] # Start to calcuate the URL url = "%s?%s&chd=%s" % (self.BASE, urlencode(self.options), encoded_data) # Calculate axis options if self.axes: axis_options = SortedDict() axis_sides = [] for i, axis in enumerate(self.axes): axis_sides.append(axis.side) for opt in axis.options: axis_options.setdefault(opt, []).append(axis.options[opt] % i) # Turn the option lists into strings axis_sides = smart_join(",", *axis_sides) for opt in axis_options: axis_options[opt] = smart_join("|", *axis_options[opt]) url += "&chxt=%s&%s" % (axis_sides, urlencode(axis_options)) return url
class Chart(object): BASE = "http://chart.apis.google.com/chart" defaults = {"chs": "200x200", "cht": "lc"} def __init__(self): # Use a SortedDict for the options so they are added in a # deterministic manner; this eases things like dealing with cache keys # or writing unit tests. self.options = SortedDict() self.datasets = [] self.hidden_datasets = [] self.axes = [] self.datarange = None self.alt = None def clone(self): clone = self.__class__() clone.options = self.options.copy() clone.datasets = self.datasets[:] clone.hidden_datasets = self.hidden_datasets[:] clone.axes = self.axes[:] return clone def img(self, color_override=None): orig_colors = self.options.get('chco') # If color_override is set, replace the chco option with this color if color_override is not None: final_color = [] for c in self.options['chco'].split(','): if c == color_override: c = orig_colors.split(',')[0] else: c = _chart_inactive_color final_color.append(c) self.options['chco'] = ','.join(final_color) url = self.url() if orig_colors: self.options['chco'] = orig_colors width, height = self.options["chs"].split("x") if self.alt: alt = '%s' % escape(self.alt) else: alt = '' s = mark_safe('<img src="%s" width="%s" height="%s" alt="%s" />' % (escape(url), width, height, alt)) return s def url(self): if self.options.get('cht', None) == 't': self.datasets.append(self.options.pop("_mapdata")) # Figure out the chart's data range if not self.datarange: maxvalue = max( max(d) for d in chain(self.datasets, self.hidden_datasets) if d) minvalue = min( min(d) for d in chain(self.datasets, self.hidden_datasets) if d) self.datarange = (minvalue, maxvalue) # Encode data if "chds" in self.options or self.options.get('cht', None) == 'gom': # text encoding if scaling provided, or for google-o-meter type data = "|".join( encode_text(d) for d in chain(self.datasets, self.hidden_datasets)) encoded_data = "t%d:%s" % (len(self.datasets), data) else: # extended encoding otherwise data = extended_separator.join( encode_extended(d, self.datarange) for d in chain(self.datasets, self.hidden_datasets)) encoded_data = "e%d:%s" % (len(self.datasets), data) # Update defaults for k in self.defaults: if k not in self.options: self.options[k] = self.defaults[k] # Start to calculate the URL url = "%s?%s&chd=%s" % (self.BASE, urlencode( self.options), encoded_data) # Calculate axis options if self.axes: axis_options = SortedDict() axis_sides = [] for i, axis in enumerate(self.axes): axis_sides.append(axis.side) for opt in axis.options: try: axis_options.setdefault(opt, []).append( axis.options[opt] % i) except TypeError: pass # Turn the option lists into strings axis_sides = smart_join(",", *axis_sides) for opt in axis_options: axis_options[opt] = smart_join("|", *axis_options[opt]) url += "&chxt=%s&%s" % (axis_sides, urlencode(axis_options)) return url def charts(self): res = [] count = 1 for o in self.options['_final_color_map'].items(): res.append({ 'id': count, 'color': o[0], 'label': o[1], 'img': self.img(color_override=o[0]) }) count += 1 return res
class Chart(object): BASE = "http://chart.apis.google.com/chart" defaults = {"chs": "200x200", "cht": "lc"} def __init__(self): # Use a SortedDict for the opeions so they are added in a # deterministic manner; this eases things like dealing with cache keys # or writing unit tests. self.options = SortedDict() self.datasets = [] self.axes = [] self.datarange = None self.alt = None def clone(self): clone = self.__class__() clone.options = self.options.copy() clone.datasets = self.datasets[:] clone.axes = self.axes[:] return clone def img(self): url = self.url() width, height = self.options["chs"].split("x") if self.alt: alt = 'alt="%s" ' % escape(self.alt) else: alt = '' s = mark_safe('<img src="%s" width="%s" height="%s" %s/>' % (escape(url), width, height, alt)) return s def url(self): if self.options.get('cht', None) == 't': self.datasets.append(self.options.pop("_mapdata")) # Figure out the chart's data range if not self.datarange: if self.datasets == [[]]: maxvalue = 0 minvalue = 0 else: maxvalue = max(max(d) for d in self.datasets if d) minvalue = min(min(d) for d in self.datasets if d) self.datarange = (minvalue, maxvalue) # Encode data if "chds" in self.options or self.options.get('cht', None) == 'gom': # text encoding if scaling provided, or for google-o-meter type data = "|".join(encode_text(d) for d in self.datasets) encoded_data = "t:%s" % data else: # extended encoding otherwise data = extended_separator.join( encode_extended(d, self.datarange) for d in self.datasets) encoded_data = "e:%s" % data # Update defaults for k in self.defaults: if k not in self.options: self.options[k] = self.defaults[k] # Start to calcuate the URL url = "%s?%s&chd=%s" % (self.BASE, urlencode( self.options), encoded_data) # Calculate axis options if self.axes: axis_options = SortedDict() axis_sides = [] for i, axis in enumerate(self.axes): axis_sides.append(axis.side) for opt in axis.options: axis_options.setdefault(opt, []).append(axis.options[opt] % i) # Turn the option lists into strings axis_sides = smart_join(",", *axis_sides) for opt in axis_options: axis_options[opt] = smart_join("|", *axis_options[opt]) url += "&chxt=%s&%s" % (axis_sides, urlencode(axis_options)) return url