def resolve(self):
"""
Resolve the entry point from its module and attrs.
"""
module = __import__(self.module_name, fromlist=['__name__'], level=0)
try:
return functools.reduce(getattr, self.attrs, module)
except AttributeError as exc:
raise ImportError(str(exc))
python类reduce()的实例源码
def __invert__(self):
members, uncovered = _decompose(self.__class__, self._value_)
inverted_members = [
m for m in self.__class__
if m not in members and not m._value_ & self._value_
]
inverted = reduce(_or_, inverted_members, self.__class__(0))
return self.__class__(inverted)
def gather_nd(params, indices, shape):
rank = len(shape)
flat_params = tf.reshape(params, [-1])
multipliers = [reduce(lambda x, y: x*y, shape[i+1:], 1) for i in range(0, rank)]
indices_unpacked = tf.unstack(tf.transpose(indices, [rank - 1] + list(range(0, rank - 1))))
flat_indices = sum([a*b for a,b in zip(multipliers, indices_unpacked)])
return tf.gather(flat_params, flat_indices)
# ctc_label_dense_to_sparse is taken from https://github.com/tensorflow/tensorflow/issues/1742#issuecomment-205291527
#
# The CTC implementation in TensorFlow needs labels in a sparse representation,
# but sparse data and queues don't mix well, so we store padded tensors in the
# queue and convert to a sparse representation after dequeuing a batch.
#
def gather_nd(params, indices, shape):
rank = len(shape)
flat_params = tf.reshape(params, [-1])
multipliers = [reduce(lambda x, y: x*y, shape[i+1:], 1) for i in range(0, rank)]
indices_unpacked = tf.unstack(tf.transpose(indices, [rank - 1] + list(range(0, rank - 1))))
flat_indices = sum([a*b for a,b in zip(multipliers, indices_unpacked)])
return tf.gather(flat_params, flat_indices)
# ctc_label_dense_to_sparse is taken from https://github.com/tensorflow/tensorflow/issues/1742#issuecomment-205291527
#
# The CTC implementation in TensorFlow needs labels in a sparse representation,
# but sparse data and queues don't mix well, so we store padded tensors in the
# queue and convert to a sparse representation after dequeuing a batch.
#
def get_foreign(self, queryset, search, filters):
# Filter with search string
query = [Q(code__icontains=search), ]
for lang in settings.LANGUAGES_DATABASES:
query.append(Q(**{"{}__name__icontains".format(lang.lower()): search}))
qs = queryset.filter(
reduce(operator.or_, query)
)
family = filters.get('FeatureForm_family', None)
if family is None:
family = filters.get('AttributeForm_family', None)
if family is None:
family = filters.get('FeatureSpecialForm_family', None)
if family is None:
family = filters.get('ProductForm_family', None)
if family is None:
family = filters.get('ProductFormCreate_family', None)
if family is None:
family = filters.get('ProductFormCreateCustom_family', None)
if family:
qs = qs.filter(family__pk=family)
return qs[:settings.LIMIT_FOREIGNKEY]
# ###########################################
def model_baseline(s_x_, s_pdpo_):
'''very simple logistic regression model'''
global g_mdl, g_dataset
s_bsize = T.shape(s_x_)[0]
idim, odim = reduce(int.__mul__, g_dataset.imsize), len(g_dataset.label_map)
return T.nnet.softmax(
g_mdl.op_dropout(g_mdl.lyr_linear(
'm', T.reshape(s_x_, (s_bsize,idim)),
idim, odim), s_pdpo_))
def visit_Assign(self, t):
def compose(left, right): return op.DUP_TOP + left + right
return self(t.value) + reduce(compose, map(self, t.targets))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def visit_Assign(self, t):
def compose(left, right): return op.DUP_TOP + left + right
return self(t.value) + reduce(compose, map(self, t.targets))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def visit_Assign(self, t):
def compose(left, right): return op.DUP_TOP + left + right
return self(t.value) + reduce(compose, map(self, t.targets))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def visit_Assign(self, t):
def compose(left, right): return op.DUP_TOP + left + right
return self(t.value) + reduce(compose, map(self, t.targets))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def visit_Assign(self, t):
def compose(left, right): return op.DUP_TOP + left + right
return self(t.value) + reduce(compose, map(self, t.targets))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def visit_BoolOp(self, t):
op_jump = self.ops_bool[type(t.op)]
def compose(left, right):
after = Label()
return left + op_jump(after) + OffsetStack() + right + after
return reduce(compose, map(self, t.values))
def resolve(self):
"""
Resolve the entry point from its module and attrs.
"""
module = __import__(self.module_name, fromlist=['__name__'], level=0)
try:
return functools.reduce(getattr, self.attrs, module)
except AttributeError as exc:
raise ImportError(str(exc))
def has_result_of_status(self, status, results):
inbound_str = self.items["operation"]["inbound"]
query = Query()
result_q = reduce(or_, [
query.result == a_result for a_result in results])
querys = [query.inbound == inbound_str,
query.inbound_status_id == status.get_status_id(), result_q]
combined_query = reduce(and_, querys)
return self.search_db(combined_query)
def get_result_summaries_by_results(self, results):
query = Query()
querys = [query.result == a_result for a_result in results]
combined_query = reduce(or_, querys)
return self.search_db(combined_query)
