def get_projects_follow_list(self, exclude_private_projects=False):
projects = Project.objects \
.filter(follow__creator=self,
follow__enabled=True,
is_draft=False)
if exclude_private_projects:
projects = projects.exclude(models.Q(access=Access.PRIVATE))
now = timezone.now()
sorted_active_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.annotate(project_end=models.Max('module__phase__end_date'))\
.filter(project_start__lte=now, project_end__gt=now)\
.order_by('project_end')
sorted_future_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.filter(models.Q(project_start__gt=now)
| models.Q(project_start=None))\
.order_by('project_start')
sorted_past_projects = projects\
.annotate(project_start=models.Min('module__phase__start_date'))\
.annotate(project_end=models.Max('module__phase__end_date'))\
.filter(project_end__lt=now)\
.order_by('project_start')
return sorted_active_projects, \
sorted_future_projects, \
sorted_past_projects
def get_queue_status(self):
"""Returns the current status of the queue with statistics broken down by job type.
:returns: A list of each job type with calculated statistics.
:rtype: list[:class:`queue.models.QueueStatus`]
"""
status_dicts = Queue.objects.values(
*['job_type__%s' % f for f in JobType.BASE_FIELDS])
status_dicts = status_dicts.annotate(
count=models.Count('job_type'),
longest_queued=models.Min('queued'),
highest_priority=models.Min('priority'))
status_dicts = status_dicts.order_by('job_type__is_paused',
'highest_priority',
'longest_queued')
# Convert each result to a real job type model with added statistics
results = []
for status_dict in status_dicts:
job_type_dict = {
f: status_dict['job_type__%s' % f]
for f in JobType.BASE_FIELDS
}
job_type = JobType(**job_type_dict)
status = QueueStatus(job_type, status_dict['count'],
status_dict['longest_queued'],
status_dict['highest_priority'])
results.append(status)
return results
def order_by_position(self):
'''order by job title sort order and then by start date'''
# annotate to avoid duplicates in the queryset due to multiple positions
# sort on highest position title (= lowest number) and earliest start date (may
# not be from the same position)
return self.annotate(min_title=models.Min('user__positions__title__sort_order'),
min_start=models.Min('user__positions__start_date')) \
.order_by('min_title', 'min_start', 'user__last_name')
def join(self):
return self.aggregate(
models.Avg('value'),
models.Min('value'),
models.Max('value'),
models.Max('timestamp'),
models.Min('timestamp'),
)
def order_by_position(self):
"""order by job title sort order and then by start date"""
# annotate to avoid duplicates in the queryset due to multiple positions
# sort on highest position title (= lowest number) and earliest start date (may
# not be from the same position)
return self.annotate(
min_title=models.Min("positions__title__sort_order"),
min_start=models.Min("positions__start_date"),
).order_by("min_title", "min_start", "last_name")
def max_bounds(cls):
cache_key = 'mapdata:max_bounds:%s:%s' % (cls.__name__, MapUpdate.current_cache_key())
result = cache.get(cache_key, None)
if result is not None:
return result
result = cls.objects.all().aggregate(models.Min('left'), models.Min('bottom'),
models.Max('right'), models.Max('top'))
result = ((float(result['left__min']), float(result['bottom__min'])),
(float(result['right__max']), float(result['top__max'])))
cache.set(cache_key, result, 900)
return result
def migrate_to_hourly_trade_aggregations(apps, *_, **__):
Trade = apps.get_model('trades', 'Trade')
HourlyTradeAggregate = apps.get_model('trades', 'HourlyTradeAggregate')
earliest_trade = Trade.objects.first()
if not earliest_trade:
return
earliest_trade_date = earliest_trade.created
running_date = Trade.objects.last().created
while running_date >= earliest_trade_date:
# get all trades for this hour
trades_for_this_hour_queryset = Trade.objects.filter(
created__lt=running_date,
created__gte=(running_date - timedelta(hours=1)),
)
# aggregate trades by currency combinations
if trades_for_this_hour_queryset.exists():
for buy_currency_id in CURRENCIES.keys():
for sell_currency_id in CURRENCIES.keys():
# filter trades by buy and sell
# create aggregate data dictionary
hourly_aggregates = trades_for_this_hour_queryset.filter(
buy_currency_id=buy_currency_id,
sell_currency_id=sell_currency_id,
).aggregate(
hour_created=models.Min('created'),
low=models.Min('trade_ratio'),
high=models.Max('trade_ratio'),
average=models.Avg('trade_ratio'),
total=models.Count('id'),
)
# create aggregate data object
if hourly_aggregates.get('total'):
new_hourly_object = HourlyTradeAggregate.objects.create(
buy_currency_id=buy_currency_id,
sell_currency_id=sell_currency_id,
low_ratio=hourly_aggregates.get('low'),
average_ratio=hourly_aggregates.get('average'),
high_ratio=hourly_aggregates.get('high'),
number_of_trades=hourly_aggregates.get('total'),
)
# reassign created date on object
new_hourly_object.created = hourly_aggregates.get(
'hour_created')
new_hourly_object.save()
# delete all trades in date range
trades_for_this_hour_queryset.delete()
# decriment date
running_date -= timedelta(hours=1)
def students(request):
semester = Semester.objects.get_next()
t0_time_agg = models.Min('t0times__time',
filter=models.Q(t0times__semester=semester))
group_opening_agg = models.Min(
'groupopeningtimes__time',
filter=models.Q(groupopeningtimes__group__course__semester=semester))
students = Student.get_active_students().select_related('user').annotate(
min_t0=t0_time_agg).annotate(
min_opening_time=group_opening_agg).order_by('min_opening_time')
return render(request, 'statistics/students_list.html', {
'students': students,
})
def get_next(kind, sentiment=None):
if sentiment:
lower_bound = sentiment - 1
upper_bound = sentiment + 1
phrase = Phrase.objects.filter(
kind=kind,
sentiment__gte=lower_bound,
sentiment__lte=upper_bound
).annotate(models.Min('used')).order_by('used')[0]
else:
phrase = Phrase.objects.filter(kind=kind).annotate(models.Min('used')).order_by('used')[0]
phrase.used += 1
phrase.save()
return phrase.text.replace('-', ' ')
def get_earliest_created_at(cls):
"""
Returns the earliest created_at time, or None
"""
result = cls.objects.aggregate(
earliest_created_at=models.Min('created_at'))
return result['earliest_created_at']
def obtain_c_toptype_list():
type_list = []
qs = RecycleBin.objects.all()
for c_type in ProductTopType.objects.filter(
operator=top_type_choice.CONSUMER, in_use=True):
try:
unit = c_type.c_subtype.filter(in_use=True).first().unit
except AttributeError:
unit = None
dic = {
"type_id":
c_type.id,
"c_type":
c_type.t_top_name,
"unit":
unit,
"min_price":
qs.filter(product_subtype__p_type__toptype_c=c_type,
product_subtype__p_type__in_use=True).aggregate(
models.Min("product_subtype__price"))
["product_subtype__price__min"],
"max_price":
qs.filter(product_subtype__p_type__toptype_c=c_type,
product_subtype__p_type__in_use=True).aggregate(
models.Max("product_subtype__price"))
["product_subtype__price__max"]
}
type_list.append(dic)
modified_time = qs.filter(product_subtype__p_type__in_use=True).aggregate(
models.Max("product_subtype__modified_time")
)["product_subtype__modified_time__max"]
return type_list, modified_time
def __get_raw_group_privilege(self, this_user):
"""
Return the group-based privilege of a specific user over this resource
:param this_user: the user upon which to report
:return: integer privilege 1-4 (PrivilegeCodes)
This does not account for resource flags.
"""
if __debug__: # during testing only, check argument types and preconditions
assert isinstance(this_user, User)
if not this_user.is_active:
raise PermissionDenied("Grantee user is not active")
# Group privileges must be aggregated
group_priv = GroupResourcePrivilege.objects\
.filter(resource=self.resource,
group__gaccess__active=True,
group__g2ugp__user=this_user)\
.aggregate(models.Min('privilege'))
response2 = group_priv['privilege__min']
if response2 is None:
response2 = PC.NONE
return response2
def get_earliest_index(self):
return self.entries.all().aggregate(models.Min('index'))['index__min']
if index is None:
index = 0
return index
def order_by_event(self):
'''Order by earliest published event associated with profile.'''
return self.annotate(
earliest_event=models.Min(models.Case(
models.When(user__event__status=CONTENT_STATUS_PUBLISHED,
then='user__event__start_time')))
).order_by('earliest_event')
def get_start_finish_dates(self):
"""
Retrieves the earliest start and the latest finish from all
associated SemesterDateRange's.
This is robust: if there are no SemesterDateRange's
associated with this instance, than the return value will still
be (relatively) meaningful based on the term,
i.e., Jan - Apr; May - Aug; Sep - Dec.
"""
results = self.semesterdaterange_set.aggregate(
min=models.Min("start"), max=models.Max("finish"))
start = results["min"]
finish = results["max"]
term_int = int(self.term[0])
if start is None:
month = 4 * (term_int - 1) + 1
start = datetime.date(self.year, month, 1)
if finish is None:
month = 4 * term_int + 1
year = self.year
if month > 12:
month -= 12
year += 1
finish = datetime.date(year, month, 1) - datetime.timedelta(days=1)
return start, finish
def get_value(self, obj):
to_currency = self.context.get('to_currency', None)
try:
search_term = obj.integralfilter.name.data.values()
except AttributeError:
search_term = str(obj.integralfilter.name)
if to_currency and ('Price' in search_term):
original_prices = obj.integralfilter.integral_choices.values_list(
'room_characteristics__price_currency__code',
'selected_number')
converted_prices = []
for from_currency, original_price in original_prices:
if not from_currency:
from_currency = 'USD'
converted_prices.append(
int(
convert_money(Money(original_price, from_currency),
to_currency).amount))
self.min_value = min(converted_prices)
self.max_value = max(converted_prices)
else:
aggregate_min_max = obj.integralfilter.integral_choices.aggregate(
django_models.Max('selected_number'),
django_models.Min('selected_number'))
self.min_value = aggregate_min_max['selected_number__min']
self.max_value = aggregate_min_max['selected_number__max']
return [self.min_value, self.max_value]
def get_annotations(
aggregation: str,
aggregation_field: str = None,
percentile: str = None,
queryset: models.QuerySet = None,
additional_filter: str = None,
) -> dict:
if aggregation == Aggregation.COUNT:
return {"value": models.Count('id')}
if aggregation == Aggregation.PERCENT:
if not additional_filter:
raise ValidationError({"error": "'additionalFilter' is required for 'aggregation=percent'"}, code=422)
complex_filter = ComplexFilter(model=queryset.model)
additional_query, _ = complex_filter.generate_from_string(additional_filter)
if not additional_query:
raise ValidationError({"error": "Additional filter cannot be empty"}, code=422)
return {
"numerator": CountIf(additional_query),
"denominator": models.Count("id"),
"value": models.ExpressionWrapper(
models.F("numerator") * 1.0 / models.F("denominator"),
output_field=models.FloatField())
}
if not aggregation_field:
raise ValidationError({"error": f"'aggregationField' is required for 'aggregation={aggregation}'"}, code=422)
if aggregation == Aggregation.DISTINCT:
return {"value": models.Count(aggregation_field, distinct=True)}
if aggregation == Aggregation.SUM:
return {"value": models.Sum(aggregation_field)}
if aggregation == Aggregation.AVERAGE:
return {"value": models.Avg(aggregation_field)}
if aggregation == Aggregation.MIN:
return {"value": models.Min(aggregation_field)}
if aggregation == Aggregation.MAX:
return {"value": models.Max(aggregation_field)}
if aggregation == Aggregation.PERCENTILE:
if not percentile:
raise ValidationError({"error": "'percentile' is required for 'aggregation=percentile'"}, code=422)
model: models.Model = queryset.model
field = None
for field_name in aggregation_field.split("__"):
field = getattr(field, field_name) if field else model._meta.get_field(field_name)
if field.get_internal_type() != "FloatField":
return {"value": Percentile(aggregation_field, percentile,
output_field=models.FloatField())}
return {"value": Percentile(aggregation_field, percentile)}
raise ValidationError({"error": "Unknown value for param 'aggregation'"}, code=422)
def winning_times(cls, qs=None):
if qs is None:
qs = cls.all_times().filter(seconds__gt=0)
values = qs.values_list('date').annotate(
winning_time=models.Min('seconds'))
return {date: winning_time for date, winning_time in values}
def get_aggregates(values, stride_field, value_field):
try:
return values.aggregate(min_stride=models.Min(stride_field), max_stride=models.Max(stride_field),
min_value=models.Min(value_field), max_value=models.Max(value_field),
count=models.Count('*'))
except (AttributeError, FieldError):
values = list(values)
if not values:
return {'count': 0}
return {
'min_stride': values[0][stride_field],
'max_stride': values[-1][stride_field],
'min_value': min(values, key=lambda value: value[value_field])[value_field],
'max_value': max(values, key=lambda value: value[value_field])[value_field],
'count': len(values),
}
def get_price_range(self):
"""
Get price range (f.e. 100 rub. - 300 rub.)
:return: {'low':Decimal, 'hight':Decimal, 'field_type':FieldType of price}
"""
try:
price_field_type = FieldType.objects.get(name='price',
category=self.category)
res = Characteristic.objects\
.filter(
field_type=price_field_type,
modification__item=self
)\
.annotate(
price_decimal=ExpressionWrapper(
F('value'),
output_field=models.DecimalField()
)
)\
.aggregate(
low=models.Min('price_decimal'),
hight=models.Max('price_decimal')
)
res['field_type'] = price_field_type
return res
except models.ObjectDoesNotExist:
return None
def _stats_for(query_set):
return {
'count': query_set.count(), 'average': query_set.aggregate(
models.Avg('score')), 'minimum': query_set.aggregate(
models.Min('score')), 'maximum': query_set.aggregate(
models.Max('score')), 'words': query_set.values('word').annotate(
models.Count("id")).order_by()}, query_set
def get_products(request):
page = request.GET.get('page', 1)
queryset = Item.objects\
.values('product__id', 'product__name')\
.annotate(min_price=models.Min('price'))\
.order_by('min_price')
if 'name' in request.GET:
queryset = queryset.filter(product__name__icontains=request.GET['name'].strip())
paginator = Paginator(queryset, per_page=request.GET.get('per-page', 10))
products = paginator.page(page)
for product in products:
product['items'] = Item.objects\
.filter(product__id=product['product__id'])\
.values(
'product__shop__name',
'product__shop__inn',
'price',
'sum',
'quantity',
'check_model__date',
)\
.order_by('-check_model__date')[:10]
return {
'products': products[:],
'num_pages': paginator.num_pages,
'count': paginator.count,
'page': page,
}
def json_sessions(self):
return {
"experiment_sessions": [
es.json_min() for es in self.ES.all().annotate(
first_date=models.Min("ESD__date")).order_by('-first_date')
],
}
def get_projects_list(self, user):
projects = query.filter_viewable(self.projects, user)
now = timezone.now()
min_module_start = models.Min('module__phase__start_date',
filter=models.Q(module__is_draft=False))
max_module_end = models.Max('module__phase__end_date',
filter=models.Q(module__is_draft=False))
sorted_active_projects = projects\
.annotate(project_start=min_module_start)\
.annotate(project_end=max_module_end)\
.filter(project_start__lte=now, project_end__gt=now)\
.order_by('project_end')
sorted_future_projects = projects\
.annotate(project_start=min_module_start)\
.filter(models.Q(project_start__gt=now)
| models.Q(project_start=None))\
.order_by('project_start')
sorted_past_projects = projects\
.annotate(project_start=min_module_start)\
.annotate(project_end=max_module_end)\
.filter(project_end__lt=now)\
.order_by('project_start')
return sorted_active_projects, \
sorted_future_projects, \
sorted_past_projects
def start(self):
""" get earliest start time from related TaskDays
:return: earliest
"""
earliest = list(
self.taskday_set.aggregate(models.Min('date')).values())[0]
return earliest
def loop():
"""
Loop forever looking for tasks and processing them in order.
"""
global _exitLoop
_exitLoop = False
def sigtermHandler(signum, frame):
global _exitLoop
logging.info('Received signal, ' +
'will end processing after current task completes')
_exitLoop = True
signal.signal(signal.SIGTERM, sigtermHandler)
signal.signal(signal.SIGINT, sigtermHandler)
while True:
try:
if _exitLoop:
logging.info('Task processing loop exiting')
return
if not Task.objects.count():
time.sleep(3)
continue
minId = Task.objects.aggregate(models.Min('id'))['id__min']
t = Task.objects.get(id=minId)
t.delete()
process(t.taskType, t.modelId)
except:
# recover from an unexpected exception thrown by the task processor
logging.error(traceback.format_exc())
def past_and_running_modules(self):
"""Return past and running modules ordered by start date."""
return self\
.filter(is_draft=False)\
.annotate(module_start=models.Min('phase__start_date'))\
.filter(module_start__lte=timezone.now())\
.order_by('module_start')
def clean(self):
result = Bid.objects.all().aggregate(models.Min('value'))
min_value = result['value__min']
if (min_value is not None and self.value < min_value):
raise ValidationError(
f"Não é possível criar um lance menor que o menor lance de R${min_value:.2f}"
)
def elasticsearch_janitor(self,
es_url=None,
es_index=None,
dry=False,
to_daemon=False):
"""
Looks for discrepancies between postgres and elastic search numbers
Re-indexes time periods that differ in count
"""
# get range of date_created in database; assumes current time is the max
logger.debug('Starting Elasticsearch JanitorTask')
min_date = AbstractCreativeWork.objects.all().aggregate(
models.Min('date_created'))['date_created__min']
if not min_date:
logger.warning('No CreativeWorks are present in Postgres. Exiting')
return
max_date = pendulum.utcnow()
min_date = pendulum.instance(min_date)
pseudo_bisection.apply((es_url, es_index, min_date, max_date), {
'dry': dry,
'to_daemon': to_daemon
},
throw=True)
def min_priority(self) -> None:
cur_min_priority = Task.objects.all().aggregate(
models.Min('priority'))['priority__min']
self.priority = cur_min_priority - 1
self.save()
