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)
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)
