def slice(self, manager, s):
value_field = manager.model._meta.get_field(self.value)
rel_name = value_field.rel.related_name
filters = {}
for lookup, value in manager.core_filters.items():
filters['%s__%s' % (rel_name, lookup)] = value
target = get_query_set(value_field.rel.to)
return manager._do_slice(s, target, rel_name, filters)
def _count(q, queryset=None):
if queryset:
queryset = get_query_set(queryset)
if q:
queryset = queryset.complex_filter(q)
return float(queryset.count())
else:
return Tag.objects.object_set().filter(TagQ(q, field='object_set__tags'))
def __init__(self, template, queryset, **kwargs):
self.queryset = get_query_set(queryset)
self.page_size = kwargs.pop('page_size', DEFAULT_PAGE_SIZE)
self.page_var = kwargs.pop('page_var', DEFAULT_PAGE_VAR)
self.searchable = kwargs.pop('searchable', True)
self.search_var = kwargs.pop('search_var', 'q')
self.search_fields = kwargs.pop('search_fields', ())
self.search_lookup = kwargs.pop('search_lookup', 'icontains')
super(ListView, self).__init__(template, **kwargs)
def __and__(self, other):
if isinstance(other, (QuerySet, Model)):
other = get_query_set(other)
qs = self.querysets_by_model.get(other.model, None)
if not qs:
return self._clone([])
return self._clone([qs & other])
elif isinstance(other, UnionQuerySet):
models = self.models & other.models
querysets = [self.querysets_by_model[model] & other.querysets_by_model[model] for model in models]
return self._clone(querysets)
def _add_qs(self, qs):
if isinstance(qs, ModelBase) and qs._meta.abstract:
for sub in get_sub_models(qs, direct=True):
self._add_qs(sub)
else:
qs = get_query_set(qs)
if qs.model in self.querysets_by_model:
model_qs = self.querysets_by_model[qs.model]
index = self.querysets.index(model_qs)
qs = qs | model_qs
self.querysets[index] = qs
else:
self.querysets.append(qs)
self.querysets_by_model[qs.model] = qs
def cossim(a, b, queryset=None):
"cossim(a, b) = arccos(v_a, v_b) = (v_a * v_b)/(|v_a|*|v_b|) for v_x[t] = w(x, t)"
queryset = get_query_set(queryset)
p, n_a, n_b = 0, 0, 0
for t in queryset.complex_filter(a & b).tags():
if a == t or b == t:
continue
v_at = _count(a & t, queryset)
v_bt = _count(b & t, queryset)
p += v_at * v_bt
n_a += v_at ** 2
n_b += v_bt ** 2
if p == 0:
return 0
return p / (math.sqrt(n_a) * math.sqrt(n_b))
def __init__(self, queryset=None, tags=None, **kwargs):
self.union = isinstance(queryset, UnionQuerySet)
self.threshold = kwargs.pop('threshold', 0)
self.annotations = kwargs.pop('annotations', DEFAULT_ANNOTATIONS)
self.range_adjusted = kwargs.pop('range_adjusted', True)
if queryset:
if not self.union:
queryset = get_query_set(queryset)
if tags:
tags = tags & queryset.tags()
else:
tags = queryset.tags()
self.queryset = queryset
else:
self.queryset = UnionQuerySet(Tagged)
self.union = True
self.tags = tags.annotate(_count=models.Count('object_set')).order_by('-_count')
if self.threshold:
self.tags = self.tags.filter(_count__gte=self.threshold)
def coerce(self, model, subquery=False):
if self.model != ObjectIdentity:
raise AttributeError("coerce() is only available for abstract models")
qs = get_query_set(model)
if subquery:
return qs.filter(id__in=self.filter(type=Type.objects.get_for_model(model)).values('pk').query)
clone = self._clone(klass=type(qs))
query = clone.query
query.clear_select_fields()
#query.remove_inherited_models()
obj_alias = query.get_initial_alias()
obj_table = query.alias_map[obj_alias][0]
table = model._meta.db_table
alias, _ = query.table_alias(table, True)
identity_col = Object._meta.get_field('id').db_column
remove_join(query, obj_alias)
forge_join(query, table, alias, None, None, None, None)
forge_join(query, obj_table, obj_alias, table, alias, identity_col, 'id')
query.tables.insert(0, query.tables.pop())
query.model = model
# replace ObjectIdentity.pk-joins with model.pk-joins
for rhs_alias, join in query.alias_map.items():
rhs_table, rhs_alias, join_type, lhs_alias, lhs_col, rhs_col, nullable = join
if lhs_alias == obj_alias and lhs_col == 'id':
remove_join(query, rhs_alias)
forge_join(query, rhs_table, rhs_alias, table, alias, identity_col, rhs_col, join_type=join_type, nullable=nullable)
query.unref_alias(obj_alias)
# if `obj_alias` is referenced only once, then it's our forged inner join with `table`. it can be removed.
if query.alias_refcount[obj_alias] == 1:
remove_join(query, obj_alias, True)
clone.model = model
return clone
def from_prefix_notation(cls, f, key='pk', and_op='A', or_op='O', not_op='N', separator='-'):
kwargs = dict(key=key, and_op=and_op, or_op=or_op, not_op=not_op, separator=separator)
if isinstance(f, (str, unicode)):
f = StringIO(f)
c = f.read(1)
if c == and_op or c == or_op:
q0 = cls.from_prefix_notation(f, **kwargs)
comma = f.read(1)
if comma != separator:
raise ValueError("'%s' expected" % separator)
q1 = cls.from_prefix_notation(f, **kwargs)
if c == and_op:
return q0 & q1
elif c == or_op:
return q0 | q1
elif c == not_op:
return ~cls.from_prefix_notation(f, **kwargs)
else:
buf = []
while c and c in "0123456789":
buf.append(c)
c = f.read(1)
f.seek(f.tell() - 1)
return get_query_set(cls.model).get(**{key: "".join(buf)})
def coerce(self, model):
qs = self.querysets_by_model.get(model, None)
if not qs:
return get_query_set(model).none()
return qs
def __init__(self, queryset, **kwargs):
self.queryset = get_query_set(queryset)
super(CloudView, self).__init__(**kwargs)
def __init__(self, queryset, pk_var='pk', **kwargs):
super(TaggedObjectDetailView, self).__init__(**kwargs)
self.queryset = get_query_set(queryset)
self.pk_var = pk_var
self.slug_lookup = 'slug'
