def negate(self): # INTERNAL: negate sall coefficients, modify self qterms = self._quadterms for qvp, qk in six_iteritems(qterms): qterms[qvp] = -qk self._linexpr.negate() self.notify_modified(event=UpdateEvent.QuadExprGlobal) return self
def __init__(self, model, quads=None, linexpr=None, name=None, safe=False): Expr.__init__(self, model, name) self._transient = False self._subscribers = [] # used by subscription mixin if quads is None: self._quadterms = self._new_term_dict() elif isinstance(quads, dict): if safe: self._quadterms = quads else: # check safe_quads = self._new_term_dict() for qvp, qk in six_iteritems(quads): model._typecheck_num(qk) if not isinstance(qvp, VarPair): self.fatal("Expecting variable-pair, got: {0!r}", qvp) else: safe_quads[qvp] = qk self._quadterms = safe_quads elif isinstance(quads, tuple): try: v1, v2, qk = quads if not safe: model._typecheck_var(v1) model._typecheck_var(v2) model._typecheck_num(qk, 'QuadExpr') self._quadterms = model._lfactory._new_term_dict() self._quadterms[VarPair(v1, v2)] = qk except ValueError: # pragma: no cover self.fatal("QuadExpr accepts tuples of len: 3, got: {0!r}", quads) elif is_iterable(quads): qterms = model._lfactory.term_dict_type() for qv1, qv2, qk in quads: qterms[VarPair(qv1, qv2)] = qk self._quadterms = qterms else: self.fatal("unexpected argument for QuadExpr: {0!r}", quads) # pragma: no cover if quads is not None: self._model._quad_count += 1 if linexpr is None: self._linexpr = model._lfactory.linear_expr() else: self._linexpr = model._lfactory._to_linear_expr(linexpr)
def _generate_thumbnails(self): _thumbnails = {} for name, opts in six_iteritems( settings.DJANGOCMS_YOUTUBE_THUMBNAIL_SIZES): try: thumb_opts = { 'size': (int(opts['width']), int(opts['height'])), 'subject_location': self.thumbnail.subject_location, 'crop': False, 'upscale': True, } thumb = self.thumbnail.file.get_thumbnail(thumb_opts) _thumbnails[name] = { 'url': thumb.url, 'width': opts['width'], 'height': opts['height'] } except Exception as e: logger.error('Error while generating thumbnail: %s', e) return _thumbnails
def iter_sorted_quads(self): if self.is_model_ordered(): return six_iteritems(self._quadterms) else: return self._iter_sorted_quads()
def iter_quads(self): return six_iteritems(self._quadterms)
def generate_quad_triplets(self): # INTERNAL # a generator that returns triplets (i.e. tuples of len 3) # with the variable pair and the coefficient for qvp, qk in six_iteritems(self._quadterms): yield qvp[0], qvp[1], qk
def __init__(self, *args, **kwargs): for key, value in six_iteritems(kwargs): setattr(self, key, value)
def pack(dicty): """ Convert a mapping into the MariaDB dynamic columns format """ column_count = 0 column_directory = [] directory_offset = 0 name_offset = 0 names = [] data_offset = 0 data = [] total_encname_length = 0 dicty_names_encoded = { key.encode('utf-8'): value for key, value in six_iteritems(dicty) } for encname in sorted(six_iterkeys(dicty_names_encoded), key=name_order): value = dicty_names_encoded[encname] if value is None: continue if len(encname) > MAX_NAME_LENGTH: raise DynColLimitError("Key too long: " + encname.decode('utf-8')) total_encname_length += len(encname) if total_encname_length > MAX_TOTAL_NAME_LENGTH: raise DynColLimitError("Total length of keys too long") try: encode_func = ENCODE_FUNCS[type(value)] except KeyError: raise DynColTypeError("Unencodable type {}".format(type(value))) dtype, encvalue = encode_func(value) column_count += 1 column_directory.append(name_offset) column_directory.append((data_offset << 4) + dtype) names.append(encname) name_offset += len(encname) data.append(encvalue) data_offset += len(encvalue) directory_offset += 2 data_size_flag, coldir_size_code, odd_sized_datacode = data_size(data) flags = ( 4 | # means this contains named dynamic columns data_size_flag ) enc_names = b''.join(names) buf = [ struct_pack( '<BHH', flags, column_count, len(enc_names) ), ] if not odd_sized_datacode: buf.append( struct_pack( '<' + ('H' + coldir_size_code) * (len(column_directory) // 2), *column_directory ) ) else: for i, val in enumerate(column_directory): if i % 2 == 0: # name_offset buf.append(struct_pack('<H', val)) else: # data_offset + dtype, have to cut last byte val = struct_pack('<' + coldir_size_code, val) buf.append(val[:-1]) buf.append(enc_names) buf.extend(data) return b''.join(buf)