def get_offering_costs(invoice_items):
price = Ceil(F('quantity') * F('unit_price') * 100) / 100
tax_rate = F('invoice__tax_percent') / 100
return invoice_items.values('invoice__year', 'invoice__month').annotate(
computed_price=Sum(price, output_field=FloatField()),
computed_tax=Sum(price * tax_rate, output_field=FloatField()),
)
class Restaurant(models.Model):
restaurant_ID = AutoField(primary_key=True)
owner = models.ForeignKey(UserProfile,
on_delete=models.CASCADE,
null=True,
blank=True)
name = CharField(max_length=100)
slug = models.SlugField(unique=True)
address = CharField(max_length=100, blank=True, null=True)
overview = CharField(max_length=100)
detailed = CharField(max_length=300, blank=True, null=True)
phone_number = IntegerField(blank=True, null=True)
email_address = EmailField(blank=True, null=True)
rating = IntegerField(default=0)
price = IntegerField(default=0)
picture = models.ImageField(upload_to='images/', null=True)
lat = FloatField(default=55.8642)
lng = FloatField(default=-4.2518)
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
super(Restaurant, self).save(*args, **kwargs)
def __str__(self):
return self.name
def hot_problems(duration, limit):
cache_key = 'hot_problems:%d:%d' % (duration.total_seconds(), limit)
qs = cache.get(cache_key)
if qs is None:
qs = Problem.objects.filter(is_public=True, submission__date__gt=timezone.now() - duration, points__gt=3, points__lt=25)
qs0 = qs.annotate(k=Count('submission__user', distinct=True)).order_by('-k').values_list('k', flat=True)
if not qs0:
return []
# make this an aggregate
mx = float(qs0[0])
qs = qs.annotate(unique_user_count=Count('submission__user', distinct=True))
# fix braindamage in excluding CE
qs = qs.annotate(submission_volume=Count(Case(
When(submission__result='AC', then=1),
When(submission__result='WA', then=1),
When(submission__result='IR', then=1),
When(submission__result='RTE', then=1),
When(submission__result='TLE', then=1),
When(submission__result='OLE', then=1),
output_field=FloatField(),
)))
qs = qs.annotate(ac_volume=Count(Case(
When(submission__result='AC', then=1),
output_field=FloatField(),
)))
qs = qs.filter(unique_user_count__gt=max(mx / 3.0, 1))
qs = qs.annotate(ordering=ExpressionWrapper(0.5 * F('points') * (0.4 * F('ac_volume') / F('submission_volume') + 0.6 * F('ac_rate')) + 100 * e ** (F('unique_user_count') / mx), output_field=FloatField())).order_by('-ordering').defer('description')[:limit]
cache.set(cache_key, qs, 900)
return qs
def _resolve_output_field(self):
source_fields = self.get_source_fields()
if any(isinstance(s, DecimalField) for s in source_fields):
return DecimalField()
if any(isinstance(s, IntegerField) for s in source_fields):
return FloatField()
return super()._resolve_output_field() if source_fields else FloatField()
class Village(Model):
id = IntegerField(verbose_name=_('village id'),
primary_key=True,
unique=True,
blank=False,
null=False)
name = CharField(max_length=128,
verbose_name=_('village name'),
unique=True,
blank=False,
db_index=True)
x = FloatField(verbose_name=_('coordinate x'))
y = FloatField(verbose_name=_('coordinate y'))
created = DateTimeField(verbose_name=_('created'),
auto_now=True,
auto_now_add=True)
owner = ForeignKey(User,
verbose_name=_('owner'),
db_constraint=False,
null=True,
blank=True)
def __unicode__(self):
return u'[%000000000d] %s' % (self.id, self.name)
class Meta:
verbose_name = _('village')
verbose_name_plural = _('villages')
unique_together = (('x', 'y'), )
index_together = (('x', 'y'), )
class Multiplicativo_metodo(models.Model):
a = FloatField()
xo = FloatField()
m = FloatField()
n = FloatField()
class Cuadrado_metodo(models.Model):
x = FloatField()
d = FloatField()
nr = FloatField()
class MutationalSignatureMinimisationResult(models.Model):
mutational_signature = models.ForeignKey(MutationalSignature, on_delete=CASCADE)
result_type = models.CharField(max_length=1, choices=MinimisationResultType.choices)
iteration = models.IntegerField()
solution_array = ArrayField(FloatField())
fit_data = ArrayField(FloatField())
diff_data = ArrayField(FloatField())
ls_sum_diff = models.FloatField()
la_sum_diff = models.FloatField()
class Meta:
unique_together = ("mutational_signature", "result_type", "iteration")
def search(self, config, start, stop, score_field=None):
# TODO: Handle MatchAll nested inside other search query classes.
if isinstance(self.query, MatchAll):
return self.queryset[start:stop]
elif isinstance(self.query, Not) and isinstance(
self.query.subquery, MatchAll):
return self.queryset.none()
if isinstance(
self.query, Not
): # If the outermost operator is a Not, we invert the query. This is done because, if every search term is negated, the Not() will return no results, an we want to match all results instead.
query = self.query.subquery
negated = True
else:
query = self.query
negated = False
search_query = self.build_search_query(query)
match_expression = MatchExpression(
search_query,
columns=["title", "body"],
output_field=BooleanField()
) # For example: MATCH (`title`, `body`) AGAINST ('+query' IN BOOLEAN MODE)
score_expression = MatchExpression(
search_query, columns=["title"],
output_field=FloatField()) * F("title_norm") + MatchExpression(
search_query, columns=["body"], output_field=FloatField())
index_entries = IndexEntry.objects.annotate(
score=score_expression).filter(
content_type_id__in=get_descendants_content_types_pks(
self.queryset.model))
if not negated:
index_entries = index_entries.filter(match_expression)
if (
self.order_by_relevance
): # Only applies to the case where the outermost query is not a Not(), because if it is, the relevance score is always 0 (anything that matches is excluded from the results).
index_entries = index_entries.order_by(score_expression.desc())
else:
index_entries = index_entries.exclude(match_expression)
index_entries = index_entries[start:stop] # Trim the results
object_ids = {
index_entry.object_id
for index_entry in index_entries
} # Get the set of IDs from the indexed objects, removes duplicates too
results = self.queryset.filter(id__in=object_ids)
return results
class MapModel(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
passengers_number = IntegerField(default=1)
passengers_signed = IntegerField(default=0)
price = FloatField(default=0.0)
date = DateField(default=datetime.now())
hour = IntegerField(default=12)
address_start = map_fields.AddressField(max_length=500)
address_end = map_fields.AddressField(max_length=500)
address_start_lat = FloatField()
address_start_lng = FloatField()
address_end_lat = FloatField()
address_end_lng = FloatField()
waypoints = JSONField()
def species_fitness(self):
return Organism.objects.filter(
population=self.pk).values('species__rel_index').annotate(
ydata=ExpressionWrapper(Sum('fitness') /
Count('species__rel_index'),
output_field=FloatField()),
xdata=F('species__rel_index'))
def calcula_total_geral(self, *args, **kwargs):
self.tt = EstoqueItens.objects.filter(
estoque=self.estoque).values().aggregate(
Sum('valor_item', output_field=FloatField()))
self.tt = list(self.tt.values())[0]
self.tt = round(self.tt, 2)
return str(self.tt)
class First(models.Aggregate):
function = 'first'
name = 'first'
output_field = FloatField()
def __init__(self, expression, bucket):
super().__init__(expression, bucket)
class Habitation(Model):
title = CharField(max_length=20)
rooms_nb = IntegerField()
area = IntegerField()
id_address = OneToOneField(
Address, on_delete=CASCADE, blank=True,
null=True) # Shop-django / Django-address package
description = TextField()
compatibility_score = FloatField()
is_furnished = BooleanField()
price = IntegerField()
id_user_poster = ForeignKey(
CroomiesUser, on_delete=CASCADE, blank=True, null=True
) #il s'agit du gars qui met l'annonce #! remove blank=true et null=true
id_time_slots = ForeignKey(Time_slots,
on_delete=CASCADE,
blank=True,
null=True)
id_date_slots = ForeignKey(Date_slots,
on_delete=CASCADE,
blank=True,
null=True)
def __str__(self):
return "%s %s" % (self.title, self.description)
def get_context_data(self, **kwargs):
context = super(PathJsonList, self).get_context_data(**kwargs)
context["sumPath"] = round(
self.object_list.aggregate(sumPath=Coalesce(
Sum(Length('geom'), output_field=FloatField()), 0))['sumPath']
/ 1000, 1)
return context
def gerar_relatorio(request):
data_fin = datetime.now()
data_ini = data_fin - timedelta(30)
vendas = ordem_de_venda.objects.filter(
ativo=True, venda=True, data_de_venda__range=[data_ini, data_fin]
).select_related('id_lote_medicamento').select_related(
'id_medicamento').values(
'id_lote_medicamento__id_medicamento__nome_medicamento').annotate(
quant=Sum('quantidade', output_Field=FloatField()),
valor=Sum(
'valor_total_venda',
output_Field=FloatField())).annotate(avg=ExpressionWrapper(
F('valor') /
F('quant'), output_field=FloatField())).order_by()
response = HttpResponse(content_type='application/vnd.ms-excel')
response['Content-Disposition'] = 'attachment; filename = Expenses' + str(
datetime.now()) + '.xls'
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('Expenses')
row_num = 0
font_style = xlwt.XFStyle()
font_style.font.bold = True
columns = [
'id_lote_medicamento__id_medicamento__nome_medicamento', 'quant',
'valor', 'avg'
]
font_style = xlwt.XFStyle
ws.write(row_num, 0, "Medicamento")
ws.write(row_num, 1, "Quantidade")
ws.write(row_num, 2, "Valor")
ws.write(row_num, 3, "Preço médio")
for row in vendas:
row_num += 1
for col_num in range(len(columns)):
ws.write(row_num, col_num, str(row[columns[col_num]]))
wb.save(response)
return response
def getRentalsForSummary(current_date=None):
result_dict = {}
created_today_filter = Q(created_date__date=current_date)
ends_today_filter = Q(end_date__date=current_date)
paid_filter = Q(paid=True)
unpaid_filter = Q(Q(paid=False) | Q(paid__isnull=True))
rentals = Rental.objects.filter(
ends_today_filter).annotate(
rent_duration=ExpressionWrapper(
( (F('end_date') - F('start_date')) * 0.000001 \
/ Value('3600', IntegerField() )),
output_field=DecimalField(decimal_places=1)
)
)
rent_subquery = rentals.filter(rentaldetail=OuterRef('id'))
rentals_detail = RentalDetail.objects.filter(
rental__in=rentals).select_related('rental').annotate(
rent_duration=Subquery(rent_subquery.values('rent_duration'))
).annotate(item_rent_gross_amt=ExpressionWrapper(
F('rent_duration') * F('price') * F('quantity'),
output_field=FloatField()))
rent_detail_subquery = rentals_detail.filter(
rental_id=OuterRef('id')).values('item_rent_gross_amt')
test = rent_detail_subquery.values('rental_id').annotate(
total=Sum('item_rent_gross_amt')).values('total')
rentals = rentals.prefetch_related(
Prefetch('rentaldetail_set',
rentals_detail)).annotate(total_rent_amt=Subquery(test))
students_with_rentals = Student.objects.filter(
Q(rental__in=rentals)).prefetch_related(
Prefetch(
'rental_set',
rentals)).annotate(student_total_rent_amt=Subquery(
rentals.values('student_id').annotate(
total_amt=Sum('total_rent_amt')).values(
'total_amt'))).order_by('name').distinct()
# Aggregates used for overall summary
rentals_counts = rentals.aggregate(
ends_today=Count('*'),
paid=Count('paid', filter=paid_filter),
)
total_rentals_value = rentals_detail.aggregate(
sum=Sum('item_rent_gross_amt'))
result_dict['count'] = rentals_counts
result_dict['total_profit'] = total_rentals_value
result_dict['students'] = students_with_rentals
return result_dict
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
if (self.kwargs):
self.current_date = self.kwargs['summary_date']
lessons_today = Lesson.objects.filter(
start_date=self.current_date).order_by('start_time')
# .annotate(
# students_detail_duration_sum=Sum('lessondetail__duration')
# )
lesson_detail = LessonDetail.objects.filter(
Q(lesson__in=lessons_today))
instructors_with_lessons = self.queryset.prefetch_related(
Prefetch('lessons', lessons_today)).annotate(
lessondetail_duration_sum=Sum(
'lessons__lessondetail__duration',
filter=Q(lessons__lessondetail__in=lesson_detail))
).annotate(instructor_lessons_duration_sum=Sum(
'lessons__duration', filter=Q(
lessons__in=lessons_today))).annotate(
lessons_price_sum=Sum(
'lessons__lessondetail__price',
filter=Q(lessons__lessondetail__in=lesson_detail)))
context['rentals'] = RentalView.getRentalsForSummary(self.current_date)
context['instructors_with_lessons'] = instructors_with_lessons
context['profit'] = lesson_detail.values(
'duration', 'pay_rate',
'lesson_id').annotate(lesson_cost=ExpressionWrapper(
F('duration') *
F('pay_rate'), output_field=FloatField())).aggregate(
total_profit=Sum('lesson_cost'))
# context['duration_sum'] = lessons_today.aggregate(sum=(Sum('duration')))
context['duration_sum'] = lesson_detail.aggregate(
sum=(Sum('duration')))
context['lesson_detail'] = lesson_detail
context['single_lessons_count'] = lessons_today.filter(
group_lesson=False).count()
context['group_lessons_count'] = lessons_today.filter(
group_lesson=True).count()
context['completed_count'] = lessons_today.filter(
completed=True).count()
context['lessons_count'] = lessons_today.count()
# context['hours'] = range(7,22)
context['current_date'] = self.current_date
context['current_time'] = datetime.today().hour
context['previous_date'] = self.current_date - timedelta(days=1)
context['next_date'] = datetime.date(self.current_date +
timedelta(days=1))
return context
class Flavor(Model):
name = CharField(max_length=255)
label = CharField(max_length=255)
parent = ForeignKey("self", blank=True, null=True, on_delete=SET_NULL)
float_value = FloatField(null=True)
decimal_value = DecimalField(null=True, max_digits=10, decimal_places=2)
def __str__(self):
return self.name
class Shape(models.Model):
type = models.CharField(max_length=16, choices=ShapeType.choices())
occluded = models.BooleanField(default=False)
z_order = models.IntegerField(default=0)
points = FloatArrayField()
rotation = FloatField(default=0)
class Meta:
abstract = True
default_permissions = ()
class Variance(Aggregate):
name = 'Variance'
output_field = FloatField()
def __init__(self, expression, sample=False, **extra):
self.function = 'VAR_SAMP' if sample else 'VAR_POP'
super().__init__(expression, **extra)
def _get_repr_options(self):
return {**super()._get_repr_options(), 'sample': self.function == 'VAR_SAMP'}
def gerar_relatorio_pessoa(request, pessoa_cpf):
id_pessoa = cliente.objects.filter(ativo=True, cpf = pessoa_cpf).\
values('nome_cliente', 'id_cliente')
id = id_pessoa[0]['id_cliente']
vendas = ordem_de_venda.objects.filter(ativo=True,venda=True, id_cliente = id). \
select_related('id_lote_medicamento', 'id_cliente').select_related('id_medicamento').\
values('id_lote_medicamento__id_medicamento__nome_medicamento'). \
annotate(quant = Sum('quantidade', output_Field = FloatField()), \
nCompras = Count('quantidade', output_Field = FloatField()), \
aux = ExpressionWrapper(F('percentual_desconto')*F('quantidade'), output_field=FloatField()), \
diaS = Sum(ExtractDay('data_de_venda')*F('quantidade'), output_Field = FloatField())). \
annotate(descS = Sum('aux')). \
annotate( avg = ExpressionWrapper( F('quant')/F('nCompras'), output_field=FloatField())). \
annotate( desc = ExpressionWrapper( F('descS')/F('quant'), output_field=FloatField())). \
annotate( dia = ExpressionWrapper( F('diaS')/F('quant'), output_field=FloatField())). \
order_by('quant')
dt = datetime.now()
response = HttpResponse(content_type='application/vnd.ms-excel')
response[
'Content-Disposition'] = 'attachment; filename = Relatório de vendas - ' + id_pessoa[
0]['nome_cliente'] + str(date(dt.year, dt.month, dt.day)) + '.xls'
wb = xlwt.Workbook(encoding='utf-8')
ws = wb.add_sheet('Pessoas')
row_num = 0
columns = [
'id_lote_medicamento__id_medicamento__nome_medicamento', 'avg', 'dia',
'desc', 'quant'
]
style = xlwt.XFStyle()
font = xlwt.Font()
font.bold = True
style.font = font
style_string = "font: bold on; borders: bottom dashed"
style = xlwt.easyxf(style_string)
ws.write(row_num, 0, "Medicamento", style=style)
ws.write(row_num, 1, "Média por compra", style=style)
ws.write(row_num, 2, "Dia médio", style=style)
ws.write(row_num, 3, "Desconto médio", style=style)
ws.write(row_num, 4, "Quantidade comprada", style=style)
for row in vendas:
row_num += 1
for col_num in range(len(columns)):
ws.write(row_num, col_num, row[columns[col_num]])
wb.save(response)
return response
def get_items_in_location(char_loc, item_source=None):
loc = ItemLocation.objects.get(character_location=char_loc,
corp_hanger=None)
if item_source is None:
item_source = InventoryItem.objects.filter(quantity__gt=0)
unstacked_items = (item_source.filter(
stack__isnull=True, contract__isnull=True,
location=loc).annotate(estimated_profit_sum=ExpressionWrapper(
Coalesce(F("item__cached_lowest_sell"), 0) *
(F("quantity") + Coalesce(F("marketorder__quantity"), 0)),
output_field=FloatField(),
)).order_by("-estimated_profit_sum"))
stacked_items = item_source.filter(
stack__isnull=False, contract__isnull=True,
location=loc).order_by("-item__cached_lowest_sell")
stacks = {}
stacks_by_item: Dict[int, List[Any]] = {}
for item in stacked_items.all():
if item.stack.id not in stacks:
stacks[item.stack.id] = {
"type": "stack",
"stack": item.stack,
"stack_id": item.stack.id,
"item": item.item,
"quantity": item.quantity,
}
if item.item.name not in stacks_by_item:
stacks_by_item[item.item.name] = []
stacks_by_item[item.item.name].append(stacks[item.stack.id])
else:
stack = stacks[item.stack.id]
if item.item != stack["item"]:
raise forms.ValidationError("Invalid Stack Found: " +
item.stack.id)
stack["quantity"] = stack["quantity"] + item.quantity
total_in_loc = len(unstacked_items) + len(
stacked_items.values("stack").distinct())
return {
"total_in_loc": total_in_loc,
"loc": char_loc,
"char": char_loc.character,
"unstacked": unstacked_items,
"stacks": {
k: stacks[k]
for k in sorted(
stacks,
key=lambda x: stacks[x]["stack"].estimated_profit() or to_isk(
0),
reverse=True,
)
},
"stacks_by_item": stacks_by_item,
}
class Assessment(TimeStampedModel):
assessor = ForeignKey(User, related_name="assessment")
engagement = ForeignKey(Engagement, related_name="assessments")
field_data = json.JSONField(blank=True, null=True)
notes = TextField(blank=True, null=True)
points_awarded = FloatField(default=0.0)
has_awarded = BooleanField(default=False)
def __unicode__(self):
return "%s assessed %s on %s" % (self.assessor, self.engagement.user,
self.engagement.assignment.worksheet)
class Variance(Aggregate):
name = "Variance"
output_field = FloatField()
def __init__(self, expression, sample=False, **extra):
self.function = "VAR_SAMP" if sample else "VAR_POP"
super().__init__(expression, **extra)
def _get_repr_options(self):
options = super()._get_repr_options()
return dict(options, sample=self.function == "VAR_SAMP")
class StdDev(Aggregate):
name = 'StdDev'
output_field = FloatField()
def __init__(self, expression, sample=False, **extra):
self.function = 'STDDEV_SAMP' if sample else 'STDDEV_POP'
super().__init__(expression, **extra)
def _get_repr_options(self):
options = super()._get_repr_options()
return dict(options, sample=self.function == 'STDDEV_SAMP')
class BM25(Func):
function = 'bm25'
output_field = FloatField()
def __init__(
self
):
expressions = tuple()
super().__init__(*expressions)
def as_sql(self, compiler: SQLCompiler, connection: BaseDatabaseWrapper, function=None, template=None):
sql, params = 'bm25(wagtailsearch_indexentry_fts)', []
return sql, params
def as_sqlite(self, compiler, connection, **extra_context):
if not getattr(connection.ops, 'spatialite', False) or connection.ops.spatial_version >= (5, 0, 0):
return self.as_sql(compiler, connection)
# This function is usually ATan2(y, x), returning the inverse tangent
# of y / x, but it's ATan2(x, y) on SpatiaLite < 5.0.0.
# Cast integers to float to avoid inconsistent/buggy behavior if the
# arguments are mixed between integer and float or decimal.
# https://www.gaia-gis.it/fossil/libspatialite/tktview?name=0f72cca3a2
clone = self.copy()
clone.set_source_expressions([
Cast(expression, FloatField()) if isinstance(expression.output_field, IntegerField)
else expression for expression in self.get_source_expressions()[::-1]
])
return clone.as_sql(compiler, connection, **extra_context)
class Flavor(Model):
name = CharField(max_length=255)
label = CharField(max_length=255)
parent = ForeignKey("self", blank=True, null=True, on_delete=SET_NULL)
float_value = FloatField(blank=True, null=True)
decimal_value = DecimalField(blank=True,
null=True,
max_digits=10,
decimal_places=2)
uuid = UUIDField(default=uuid.uuid4)
datetime = DateTimeField(blank=True, null=True)
date = DateField(blank=True, null=True)
time = TimeField(blank=True, null=True)
duration = DurationField(blank=True, null=True)
def __str__(self):
return self.name
def get(self, request):
query = None
user_id = request.GET.get('user', None)
if user_id is None:
return JsonResponse(None, safe=False)
total_count = BookStore.objects.filter(user__pk=user_id).count()
# categorical value sum, average
# Cast Float value
query = BookStore.objects.values('book_format').annotate(
sum_format=Count('book_format')
).annotate(avg_format=Cast(F('sum_format'), FloatField()) / Cast(total_count, FloatField())
).values('book_format', 'sum_format', 'avg_format')
print(list(query))
return JsonResponse(list(query), safe=False)
class MutationalSignature(models.Model):
sample = models.ForeignKey(Sample, on_delete=CASCADE)
calculator = models.ForeignKey(MutationalSignatureCalculator, on_delete=CASCADE)
import_status = models.CharField(max_length=1, choices=ImportStatus.choices, default=ImportStatus.CREATED)
summary = models.TextField()
mean = ArrayField(FloatField(), null=True)
num_snps = models.IntegerField(null=True)
class Meta:
unique_together = ("sample", "calculator")
def __str__(self):
if self.import_status == ImportStatus.SUCCESS:
description = self.summary
else:
import_status = self.get_import_status_display()
description = f"MutationalSignature {self.pk}, import_status={import_status}"
return description
