def test_invalid_values(self):
"""
If dictsortreversed is passed something other than a list of
dictionaries, fail silently.
"""
self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
self.assertEqual(dictsortreversed('Hello!', 'age'), '')
self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
self.assertEqual(dictsortreversed(1, 'age'), '')
def test_invalid_values(self):
"""
If dictsortreversed is passed something other than a list of
dictionaries, fail silently.
"""
self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
self.assertEqual(dictsortreversed('Hello!', 'age'), '')
self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
self.assertEqual(dictsortreversed(1, 'age'), '')
def test_invalid_values(self):
"""
If dictsortreversed is passed something other than a list of
dictionaries, fail silently.
"""
self.assertEqual(dictsortreversed([1, 2, 3], "age"), "")
self.assertEqual(dictsortreversed("Hello!", "age"), "")
self.assertEqual(dictsortreversed({"a": 1}, "age"), "")
self.assertEqual(dictsortreversed(1, "age"), "")
def test_invalid_args(self):
"""Fail silently if invalid lookups are passed."""
self.assertEqual(dictsortreversed([{}], "._private"), "")
self.assertEqual(dictsortreversed([{
"_private": "test"
}], "_private"), "")
self.assertEqual(
dictsortreversed([{
"nested": {
"_private": "test"
}
}], "nested._private"), "")
def sort_items_by_date(object_list, date_fields="date_published, timestamp, pub_date, date_submitted, date_created", recent_first=False):
"""
Given a list of heterogeneous items (instances from several different models) and a list of
possible date field names, sort the items by date. Any items in the list without a date field
attribute will be left out of the results. Defaults to most recent items last, but accepts a
recent_first argument to reverse the chronology.
"""
date_field_list = date_fields.split(",")
object_dict_list = []
for object in object_list:
if object:
object_date_field = None
for field in date_field_list:
for f in object._meta.fields:
if f.name == field:
object_date_field = f.name
break
if object_date_field:
object_dict = { 'date': getattr(object, object_date_field), 'object': object }
object_dict_list.append(object_dict)
if recent_first:
sorted_item_dicts = dictsortreversed(object_dict_list, 'date')
else:
sorted_item_dicts = dictsort(object_dict_list, 'date')
sorted_items = []
for item in sorted_item_dicts:
if item['object'] not in sorted_items:
sorted_items.append(item['object'])
return sorted_items
def tag_list(request):
from django.views.generic.list_detail import object_list
from django.template.defaultfilters import dictsortreversed
tags = Tag.objects.all()
tags_by_popularity = []
content_types = ContentType.objects.all()
item_count = 0
for content_type in content_types:
model = content_type.model_class()
if hasattr(model, 'tags'):
item_count = item_count + model.objects.all().count()
ct_tags = Tag.objects.usage_for_model(model, counts=True)
for tag in ct_tags:
tags_by_popularity.append(tag)
tags_by_popularity = dictsortreversed(tags_by_popularity, 'count')
extra_context = {
'tagged_item_count': item_count,
'tags_by_popularity': tags_by_popularity,
'most_popular_tag': tags_by_popularity[0],
}
return object_list(
request,
queryset=tags,
template_object_name='tag',
template_name='sections/tag_list.html',
extra_context=extra_context,
)
def test_sort_list_of_tuple_like_dicts(self):
data = [
{
'0': 'a',
'1': '42'
},
{
'0': 'c',
'1': 'string'
},
{
'0': 'b',
'1': 'foo'
},
]
expected = [
{
'0': 'c',
'1': 'string'
},
{
'0': 'b',
'1': 'foo'
},
{
'0': 'a',
'1': '42'
},
]
self.assertEqual(dictsortreversed(data, '0'), expected)
def test_sort(self):
sorted_dicts = dictsortreversed(
[
{
"age": 23,
"name": "Barbara-Ann"
},
{
"age": 63,
"name": "Ra Ra Rasputin"
},
{
"name": "Jonny B Goode",
"age": 18
},
],
"age",
)
self.assertEqual(
[sorted(dict.items()) for dict in sorted_dicts],
[
[("age", 63), ("name", "Ra Ra Rasputin")],
[("age", 23), ("name", "Barbara-Ann")],
[("age", 18), ("name", "Jonny B Goode")],
],
)
def test_sort_list_of_tuple_like_dicts(self):
data = [
{
"0": "a",
"1": "42"
},
{
"0": "c",
"1": "string"
},
{
"0": "b",
"1": "foo"
},
]
expected = [
{
"0": "c",
"1": "string"
},
{
"0": "b",
"1": "foo"
},
{
"0": "a",
"1": "42"
},
]
self.assertEqual(dictsortreversed(data, "0"), expected)
def render(self, context):
from django.template.defaultfilters import dictsortreversed
try:
tags = []
if self.model:
app_label, model_name = self.model.split('.')
content_types = [ContentType.objects.get(app_label=app_label, model=model_name)]
else:
content_types = ContentType.objects.all()
item_count = 0
for content_type in content_types:
model = content_type.model_class()
if hasattr(model, 'tags'):
item_count = item_count + model.objects.all().count()
ct_tags = Tag.objects.usage_for_model(model, counts=True)
for tag in ct_tags:
tags.append(tag)
context[self.varname] = dictsortreversed(tags, 'count')[:self.num]
context['tagged_item_count'] = item_count
except:
pass
return ''
def place_detail(request, country, city, place_slug, state=None, allow_empty=True):
from django.views.generic.list_detail import object_detail
if state:
slug = slugify(city + " " + state + " " + country)
else:
slug = slugify(city + " " + country)
try:
city = City.objects.get(slug=slug)
except:
raise Http404
try:
place = Place.objects.get(city=city, slug=place_slug)
except:
raise Http404
if "savoy.contrib.aggregator" in settings.INSTALLED_APPS:
object_list = dictsortreversed(place.aggregator_items(), 'timestamp')
else:
object_list = sort_items_by_date(place.items(), recent_first=True)
extra_context = {
'object_list' : object_list,
}
return object_detail(
request,
queryset = Place.objects.filter(city=city),
template_name = 'geo/place_detail.html',
template_object_name='place',
slug_field = 'slug',
slug = place_slug,
extra_context = extra_context,
)
def render(self, context):
from string import punctuation
from django.template.defaultfilters import dictsortreversed
try:
removelist = ["a", "an", "as", "at", "but", "by", "for", "from",
"is", "in", "into", "of", "off", "on", "onto", "per",
"since", "than", "the", "this", "that", "to", "up", "via",
"with", "and", "it", "be", "was", "i","you","me","my","is","so",
"some","it's","its","are","if","some","there", "what","just", ""]
cat_statuses = ""
for status in Status.objects.all():
cat_statuses += status.body + " "
wordlist = cat_statuses.split()
punctuation = punctuation.replace('@', '')
wordlist = [word.strip(punctuation).lower() for word in wordlist]
wordfreq = [wordlist.count(p) for p in wordlist]
dictionary = dict(zip(wordlist,wordfreq))
word_dict_list = []
for key in dictionary:
if key not in removelist and not key.startswith('@'):
word_dict_list.append({ 'name': key, 'count': dictionary[key] })
context[self.varname] = dictsortreversed(word_dict_list, 'count')[:int(self.num)]
except:
pass
return ''
def by_release_and_component_total(self, release, component):
"""
Return a list of the total translation by languages for a release and component
"""
from django.db import connection
cursor = connection.cursor()
cursor.execute("SELECT sum(t.trans), sum(t.fuzzy), "\
"sum(t.untrans), sum(t.total), t.language_id "\
"FROM pofile as t "\
"WHERE t.release_id=%s AND "\
"t.component_id=%s AND "\
"language_id is NOT NULL "\
"GROUP by language_id",
[release.id, component.id])
postats = []
for row in cursor.fetchall():
l = Language.objects.get(id=row[4])
po = self.model(trans=row[0],
fuzzy=row[1],
untrans=row[2],
total=row[3],
filename=l.code, # Not used but needed
language=l)
po.calculate_perc()
postats.append(po)
return dictsortreversed(postats,'trans_perc')
def project_usage(request, project_id):
project = get_object_or_404(Project, pid=project_id)
if (not project.can_view(request)
and not getattr(settings, 'USAGE_IS_PUBLIC', False)):
return HttpResponseForbidden('<h1>Access Denied</h1>')
result = progress(request)
if result is not None:
return result
start, end = get_date_range(request)
result = gen_cache_for_machine_category(request, start, end)
if result is not None:
return render(template_name='kgusage/progress.html',
context={'task_id': result.task_id},
request=request)
result = gen_cache_for_project(request, start, end, project)
if result is not None:
return render(template_name='kgusage/progress.html',
context={'task_id': result.task_id},
request=request)
usage_list = []
total, total_jobs = 0, 0
# Custom SQL as need to get users that were removed from project too
query = CPUJob.objects.filter(project=project, date__range=(start, end))
query = query.values('account').annotate().order_by('account')
for row in query:
u = Account.objects.get(id=row['account']).person
time, jobs = usage.get_person_usage(u, project, start, end)
if time:
total += time
total_jobs += jobs
if jobs > 0:
usage_list.append({'person': u, 'usage': time, 'jobs': jobs})
for u in usage_list:
if total == 0:
u['percent'] = 0
else:
u['percent'] = (u['usage'] / total) * 100
usage_list = dictsortreversed(usage_list, 'usage')
count = 0
for i in usage_list:
i['colour'] = graphs.get_colour(count)
count += 1
graph = graphs.get_project_trend_graph_url(project, start, end)
return render(template_name='kgusage/project_usage.html',
context=locals(),
request=request)
def test_dictsortreversed(self):
sorted_dicts = dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},
{'age': 63, 'name': 'Ra Ra Rasputin'},
{'name': 'Jonny B Goode', 'age': 18}],
'age')
self.assertEqual([sorted(dict.items()) for dict in sorted_dicts],
[[('age', 63), ('name', 'Ra Ra Rasputin')],
[('age', 23), ('name', 'Barbara-Ann')],
[('age', 18), ('name', 'Jonny B Goode')]])
# If it gets passed a list of something else different from
# dictionaries it should fail silently
self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
self.assertEqual(dictsortreversed('Hello!', 'age'), '')
self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
self.assertEqual(dictsortreversed(1, 'age'), '')
def test_dictsortreversed(self):
sorted_dicts = dictsortreversed([{'age': 23, 'name': 'Barbara-Ann'},
{'age': 63, 'name': 'Ra Ra Rasputin'},
{'name': 'Jonny B Goode', 'age': 18}],
'age')
self.assertEqual([sorted(dict.items()) for dict in sorted_dicts],
[[('age', 63), ('name', 'Ra Ra Rasputin')],
[('age', 23), ('name', 'Barbara-Ann')],
[('age', 18), ('name', 'Jonny B Goode')]])
# If it gets passed a list of something else different from
# dictionaries it should fail silently
self.assertEqual(dictsortreversed([1, 2, 3], 'age'), '')
self.assertEqual(dictsortreversed('Hello!', 'age'), '')
self.assertEqual(dictsortreversed({'a': 1}, 'age'), '')
self.assertEqual(dictsortreversed(1, 'age'), '')
def project_usage(request, project_id, machine_category_id):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
project = get_object_or_404(Project, pid=project_id)
if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
result = progress(request)
if result is not None:
return result
start, end = get_date_range(request)
result = gen_cache_for_machine_category(request, start, end, machine_category)
if result is not None:
return result
result = gen_cache_for_project(request, start, end, project, machine_category)
if result is not None:
return result
usage_list = []
total, total_jobs = 0, 0
# Custom SQL as need to get users that were removed from project too
rows = CPUJob.objects.filter(
project=project,
machine__category=machine_category,
date__range=(start, end)
).values('account').annotate().order_by('account')
for row in rows:
u = Account.objects.get(id=row['account']).person
time, jobs = usage.get_person_usage(u, project, start, end, machine_category)
if time:
total += time
total_jobs += jobs
if jobs > 0:
usage_list.append({'person': u, 'usage': time, 'jobs': jobs})
for u in usage_list:
if total == 0:
u['percent'] = 0
else:
u['percent'] = (u['usage'] / total) * 100
usage_list = dictsortreversed(usage_list, 'usage')
count = 0
for i in usage_list:
i['colour'] = graphs.get_colour(count)
count += 1
graph = graphs.get_project_trend_graph_url(project, start, end, machine_category)
return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def project_usage(request, project_id, machine_category_id=settings.DEFAULT_MC):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
project = get_object_or_404(Project, pk=project_id)
if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
if project.machine_categories.count() == 1:
machine_category = project.machine_categories.all()[0]
usage_list = []
total, total_jobs = 0, 0
querystring = request.META.get('QUERY_STRING', '')
start, end = get_date_range(request)
start_str = start.strftime('%Y-%m-%d')
end_str = end.strftime('%Y-%m-%d')
mc_ids = tuple([(int(m.id)) for m in machine_category.machine_set.all()])
if len(mc_ids) == 1:
mc_ids = "(%i)" % mc_ids[0]
# Custom SQL as need to get users that were removed from project too
cursor = connection.cursor()
sql = "SELECT user_id from cpu_job where project_id = '%s' and `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' GROUP BY user_id" % (str(project.pid), mc_ids, start_str, end_str)
cursor.execute(sql)
rows = list(cursor.fetchall())
cursor.close()
for uid in rows:
u = UserAccount.objects.get(id=uid[0]).user
time, jobs = u.get_usage(project, start, end)
if time:
total += time
total_jobs += jobs
if jobs > 0:
usage_list.append({'user': u, 'usage': time, 'jobs': jobs})
for u in usage_list:
if total == 0:
u['percent'] = 0
else:
u['percent'] = (u['usage'] / total) * 100
usage_list = dictsortreversed(usage_list, 'usage')
count = 0
for i in usage_list:
i['colour'] = get_colour(count)
count += 1
graph = get_project_trend_graph_url(project, start, end, machine_category)
return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def test_sort_list_of_tuple_like_dicts(self):
data = [
{'0': 'a', '1': '42'},
{'0': 'c', '1': 'string'},
{'0': 'b', '1': 'foo'},
]
expected = [
{'0': 'c', '1': 'string'},
{'0': 'b', '1': 'foo'},
{'0': 'a', '1': '42'},
]
self.assertEqual(dictsortreversed(data, '0'), expected)
def spot_list(request, queryset=Spot.objects.all(), template="spots/spot_list.html", relevant_to_spot=None, extra_context={}):
"""
Renders a list of spots. Defaults to all spots, but takes an optional
QuerySet argument. If a Spot is passed to the "relevant_to_spot" argument, the output
will include details as to the distance and direction of each spot from the
relevant_to_spot.
"""
spots = queryset
query = dict(request.REQUEST.items())
order_by = query.pop('order_by', '-date_created')
# If a Django QS filter was submited with the request, apply it.
if len(query):
spots = spots.filter(**format_qs(query))
# If order_by was specified, apply it (unless it's distance -- we'll handle that later).
if order_by:
if not order_by == "-distance" and not order_by == "distance":
spots = spots.order_by(*order_by.split(','))
# Create the spot dicts for rendering in templates. If relevant_to_spot was speficied,
# include the distance and direction from that spot.
if relevant_to_spot:
spots = [ {'spot': spot, 'distance': relevant_to_spot._get_distance_to_spot(spot), 'direction': relevant_to_spot._get_compass_direction_to_spot(spot) } for spot in spots ]
if order_by == '-distance': spots = dictsort(spots, 'distance')
if order_by == 'distance': spots = dictsortreversed(spots, 'distance')
else:
spots = [ {'spot': spot, 'distance': None, 'direction': None } for spot in spots ]
# Create a list of countries that have spots, for rendering in the templates.
cities_with_spots = City.objects.filter(spots__isnull=False).distinct()
countries = []
for city in cities_with_spots:
for country in COUNTRY_CHOICES:
if country[0] == city.country:
country_dict = { 'code': city.country, 'name': country[1], 'url': reverse('spot_list_for_country', args=[city.country])}
if country_dict not in countries:
countries.append(country_dict)
break
# Build the breadcrumbs for this list.
breadcrumbs, view_name = build_breadcrumbs()
# Create the context and render the template.
context = {
'spots': spots,
'order_by': order_by,
'view_name': view_name,
'countries': countries,
}
context.update(extra_context)
return render_to_response(template, context, context_instance=RequestContext(request))
def update_characteristics(self, instance, **kwargs): """ When a Review item is saved, update the Beer's characteristics with the new data. """ from django.template.defaultfilters import dictsortreversed from ninetyseven.apps.reviews.models import Review from tagging.models import Tag beer = instance.beer reviews = Review.objects.filter(beer=beer) tags = Tag.objects.usage_for_queryset(reviews, counts=True) top_tags = dictsortreversed(tags, 'count')[:5] beer.characteristics = " ".join(tag.name for tag in top_tags) beer.save()
def popular_tags(request):
poptags = Tag.objects.usage_for_model(Entry, counts=True, filters={'status': Entry.STATUS_OPEN})
poptags = dictsortreversed(poptags, 'count')
if len(poptags) < 1:
poptags_max = 0
else:
poptags_max = poptags[0].count
return {
'popular_tags': poptags,
'popular_tags_max': poptags_max,
}
def test_sort(self):
sorted_dicts = dictsortreversed(
[{'age': 23, 'name': 'Barbara-Ann'},
{'age': 63, 'name': 'Ra Ra Rasputin'},
{'name': 'Jonny B Goode', 'age': 18}],
'age',
)
self.assertEqual(
[sorted(dict.items()) for dict in sorted_dicts],
[[('age', 63), ('name', 'Ra Ra Rasputin')],
[('age', 23), ('name', 'Barbara-Ann')],
[('age', 18), ('name', 'Jonny B Goode')]],
)
def test_sort(self):
sorted_dicts = dictsortreversed(
[{'age': 23, 'name': 'Barbara-Ann'},
{'age': 63, 'name': 'Ra Ra Rasputin'},
{'name': 'Jonny B Goode', 'age': 18}],
'age',
)
self.assertEqual(
[sorted(dict.items()) for dict in sorted_dicts],
[[('age', 63), ('name', 'Ra Ra Rasputin')],
[('age', 23), ('name', 'Barbara-Ann')],
[('age', 18), ('name', 'Jonny B Goode')]],
)
def mergetweets(posts, tweetsfeed, ptentries):
elist = []
for p in posts:
elist.append(p)
for p in ptentries:
elist.append(p)
for t in tweetsfeed:
elist.append({ 'date_published': t.date_published, 'byline': '', 'text': t.title[t.title.find(': ')+2:], 'twit': t.title[:t.title.find(': ')] })
elist = dictsortreversed(elist, 'date_published')
return elist
def city_detail(request, country, city, state=None, allow_empty=True):
from django.views.generic.list_detail import object_detail
# Find the city we're dealing with based on its slug.
if state:
slug = slugify(city + " " + state + " " + country)
else:
slug = slugify(city + " " + country)
try:
city = City.objects.get(slug=slug)
except:
raise Http404
# Get the city and state name and code for inclusion in our template context.
country_name = city.get_country_display()
country_code = city.country
if country == "us":
state_name = city.get_state_display()
state_code = city.state
else:
state_name = city.province
state_code = slugify(city.province)
if "savoy.contrib.aggregator" in settings.INSTALLED_APPS:
object_list = dictsortreversed(city.aggregator_items(), 'timestamp')
else:
object_list = sort_items_by_date(city.items(), recent_first=True)
extra_context = {
'country': country_name,
'country_code': country_code,
'state': state_name,
'state_code': state_code,
'object_list': object_list,
}
# Render a generic detail view.
return object_detail(
request,
queryset = City.objects.all(),
template_name = 'geo/city_detail.html',
template_object_name='city',
slug_field = 'slug',
slug = slug,
extra_context = extra_context,
)
def render(self, context):
from string import punctuation
from django.template.defaultfilters import dictsortreversed
try:
cat_statuses = ""
for status in Status.objects.all():
cat_statuses += status.body + " "
wordlist = cat_statuses.split()
punctuation = punctuation.replace('@', '')
wordlist = [word.strip(punctuation).lower().replace("'s", '') for word in wordlist]
wordfreq = [wordlist.count(p) for p in wordlist]
dictionary = dict(zip(wordlist,wordfreq))
word_dict_list = []
for key in dictionary:
if key.startswith('@'):
word_dict_list.append({ 'name': key[1:], 'count': dictionary[key] })
context[self.varname] = dictsortreversed(word_dict_list, 'count')[:int(self.num)]
except:
pass
return ''
def gen_project_graph(self, project, start, end, machine_category):
"""Generates a bar graph for a project
Keyword arguments:
project -- Project
start -- start date
end -- end date
machine_category -- MachineCategory object
"""
today = datetime.date.today()
start_str = start.strftime('%Y-%m-%d')
end_str = end.strftime('%Y-%m-%d')
start_t = start.strftime('%d/%m/%y')
end_t = end.strftime('%d/%m/%y')
fig = Figure(figsize=(6,3))
ax = fig.add_axes([0.2, 0.2, 0.7, 0.7])
period = (end-start).days
ax.set_xlim(0,period+1)
if period < 10:
step = 1
elif period < 100:
step = 20
else:
step = 50
ax.set_xticks(arange(period+1, step=step))
#print drange(start, end, datetime.timedelta(days=2))
ax.set_title('%s %s - %s' % (project.pid, start_t, end_t))
ax.set_ylabel("CPU Time (hours)")
ax.set_xlabel("Days")
mc_ids = tuple([(int(m.id)) for m in machine_category.machine_set.all()])
if len(mc_ids) == 1:
mc_ids = "(%i)" % mc_ids[0]
t_start = start
t_end = end
b_total = 0
user_data = []
cursor = connection.cursor()
SQL = "SELECT user_id from cpu_job where project_id = '%s' and `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' GROUP BY user_id" % (str(project.pid), mc_ids, start_str, end_str)
cursor.execute(SQL)
rows = list(cursor.fetchall())
cursor.close()
for uid in rows:
try:
ua = UserAccount.objects.get(id=uid[0])
except UserAccount.DoesNotExist:
# Usage is from an unknown user.
continue
u = ua.user
cursor = connection.cursor()
SQL = "SELECT date, SUM( cpu_usage ) FROM `cpu_job` WHERE `project_id` LIKE '%s' AND `user_id` = %s AND `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' Group By date" % (str(project.pid), str(ua.id), mc_ids, start_str, end_str)
cursor.execute(SQL)
rows = dict(cursor.fetchall())
if rows:
data, dates_y, labels = [], [], []
start = t_start
end = t_end
while start <= end:
if start != today:
try:
total = float(rows[start])
except:
total = 0
data.append(total / 3600.00)
labels.append(str(start))
b_total += total
start = start + datetime.timedelta(days=1)
user_data.append({'user': u, 'data': data, 'total': sum(data)})
#print ua.user
#print data
#print '-----'
#print 'prev: %s ' % prev_data
#ax.bar(dates, data, color=colours[count], edgecolor=colours[count])
#prev_data = data
#print b_total/ 3600
count = 0
prev_data = None
# majloc = dates.AutoDateLocator()
# majfmt = dates.AutoDateFormatter(majloc)
# ax.xaxis.set_major_locator(majloc)
# ax.xaxis.set_major_formatter(majfmt)
user_data = dictsortreversed(user_data, 'total')
user_data = [d['data'] for d in user_data]
for data in user_data:
x_data = range(1, len(data) + 1)
if prev_data:
ax.bar(x_data, data, color=get_colour(count), edgecolor=get_colour(count), bottom=prev_data, align='center')
p = 0
while p < len(prev_data):
prev_data[p] += data[p]
p += 1
else:
ax.bar(x_data, data, color=get_colour(count), edgecolor=get_colour(count), align='center')
prev_data = data
count += 1
canvas = FigureCanvasAgg(fig)
canvas.print_figure("%s/projects/%s_%s-%s_%i.png" % (str(settings.GRAPH_ROOT), str(project.pid), str(start_str), str(end_str), machine_category.id))
def test_sort_list_of_tuples(self):
data = [("a", "42"), ("c", "string"), ("b", "foo")]
expected = [("c", "string"), ("b", "foo"), ("a", "42")]
self.assertEqual(dictsortreversed(data, 0), expected)
def search(
request,
template_name="aggregator/search.html",
template_loader=loader,
extra_context=None,
context_processors=None,
mimetype=None,
):
"""
ContentItem search.
Works a bit like a generic view in that you can pass a bunch of optional
keyword arguments which work just like they do in generic views. Those
arguments are: ``template_name``, ``template_loader``, ``extra_context``,
``context_processors``, and ``mimetype``.
Templates: ``aggregator/search.html`` (default)
Context:
``search_string``
The search string, as the user entered it
``search_terms``
A list of all terms searched
``items``
Search results, ordered by most recent first
``hits``
An integer representing the number of search results
``all_content_types``
List of all ContentTypes objects available to the aggregator
``content_types``
List of ContentTypes objects used to render this page
``model_string``
String representation of models appearing on this page (useful as a cache key argument)
"""
# Create search terms list.
if request.GET.__contains__("search"):
search_string = request.GET["search"]
# First, split on double-quotes to extract any multi-word terms
search_terms = search_string.split('"')
cleaned_search_terms = []
# Then, remove any unnecessary whitespace at the beginings or ends of the terms
for item in search_terms:
if not item.startswith(" ") and not item.endswith(" ") and not item == "":
cleaned_search_terms.append(item)
if item.startswith(" "):
cleaned_search_terms.append(item[1:])
if item.endswith(" "):
cleaned_search_terms.append(item[:-1])
# Filtering by model
model_query = request.GET.get("models", "default")
model_query_list = request.GET.getlist("models")
if model_query == "default":
content_types = get_aggregator_content_types(type_set="default")
model_list = [ct.app_label + "." + ct.model for ct in content_types]
model_string = "default"
elif model_query == "all":
model_string = "all"
content_types = get_aggregator_content_types(type_set="all")
else:
model_string = ",".join(model_query_list)
model_list = model_query_list
content_types = []
for item in model_list:
for model in settings.AGGREGATOR_MODELS:
if item == model["model"]:
app_label = item.split(".")[0]
model = item.split(".")[1]
content_type = ContentType.objects.get(app_label=app_label, model=model)
content_types.append(content_type)
# Set up a list to put results into
search_results = []
# Search each model for the search terms
for content_type in content_types:
content_type_string = content_type.app_label + "." + content_type.model
model = content_type.model_class()
manager = model._default_manager
opts = model._meta
query = Q()
queries = []
for model in settings.AGGREGATOR_MODELS:
if content_type_string == model["model"]:
search_fields = model["search_fields"]
for term in cleaned_search_terms:
for field in search_fields:
lookup = field + "__icontains"
kwargs = {lookup: term}
q = Q(**kwargs)
queries.append(q)
for q in queries:
query = query | q
results = manager.filter(query)
# Create a list of primary keys for each item in the results, then use that list to get a
# QuerySet of associated ContentItem objects. Append the results of that QuerySet to the
# search_results list.
result_pks = [i["pk"] for i in results.values("pk")]
result_content_items = ContentItem.objects.filter(content_type=content_type, object_id__in=result_pks)
search_results.extend(result_content_items)
items = dictsortreversed(search_results, "timestamp")
else:
cleaned_search_terms = []
search_string = ""
items = []
content_types = []
model_string = ""
hits = 0
# Build the context
context = RequestContext(
request,
{
"search_terms": cleaned_search_terms,
"search_string": search_string,
"items": items,
"all_content_types": get_aggregator_content_types(type_set="all"),
"content_types": content_types,
"model_string": model_string,
"hits": len(items),
},
context_processors,
)
if extra_context:
for key, value in extra_context.items():
if callable(value):
context[key] = value()
else:
context[key] = value
# Load, render, and return
t = template_loader.get_template(template_name)
return HttpResponse(t.render(context), mimetype=mimetype)
def test_sort_list_of_tuples(self):
data = [('a', '42'), ('c', 'string'), ('b', 'foo')]
expected = [('c', 'string'), ('b', 'foo'), ('a', '42')]
self.assertEqual(dictsortreversed(data, 0), expected)
def test_sort_list_of_tuples(self):
data = [('a', '42'), ('c', 'string'), ('b', 'foo')]
expected = [('c', 'string'), ('b', 'foo'), ('a', '42')]
self.assertEqual(dictsortreversed(data, 0), expected)
def test_invalid_args(self):
"""Fail silently if invalid lookups are passed."""
self.assertEqual(dictsortreversed([{}], '._private'), '')
self.assertEqual(dictsortreversed([{'_private': 'test'}], '_private'), '')
self.assertEqual(dictsortreversed([{'nested': {'_private': 'test'}}], 'nested._private'), '')
