def filter_header(queryset: QuerySet, field_name: str, values: str): """ Returns a desired lookup for a DicomHeader field. Parameters ---------- queryset : :class:`~django.db.models.QuerySet` The filtered queryset field_name : str The name of the field the queryset is being filtered by values : dict The fields and values to filter by """ if not values: return queryset series_all = queryset.all() values_json = json.loads(values) series_ids = [] for series in series_all: header = series.image_set.first().header.instance result = validation.run_checks(values_json, header) if result: series_ids.append(series.id) return queryset.filter(id__in=series_ids).all()
def optimized_resolve( info: graphql.ResolveInfo, queryset: djm.QuerySet, **kwargs, ) -> dict: """Resolve django queryset base on query selection. And prime dataloader cache. Args: info (graphql.ResolveInfo): Resolve info. queryset (djm.QuerySet): Queryset to resolve. Returns: dict: Connection resolve result. """ qs = qs_.optimize(queryset.all(), info) ret = resolve(qs, **kwargs) def _prime_nodes(v): for i in v: # Prime dataloader cache Resolver(info=info).resolve_gid(i) return v nodes = ret['nodes'] ret['nodes'] = lazy.Proxy(lambda: _prime_nodes(nodes)) return ret
def retry_all(qs: QuerySet) -> bool: for delay in (0.5, 1, 2, 4, None): result = all(qs.all()) if result: return result elif delay: time.sleep(delay) else: return False
def accept_entries(user_id: int, queryset: QuerySet) -> int: """ Accept all entries in the queryset :param user_id: Id of the user executing this action :param queryset: queryset of entries :type queryset: Queryset[Entry] :return: number of updated rows :rtype: integer """ queryset = queryset.filter(status=Entry.STATUS_REVIEW) entries = queryset.all() updated_entries = [] for entry in entries: # Check if the user is unique if not check_unique_user(entry): # User is not unique, do not proceed continue entry.status = Entry.STATUS_ACCEPTED entry.updated_at = timezone.now() entry.payment = _create_payment_for_entry(entry) log_obj = None try: if entry.registration.username is None: entry.registration.username = _generate_username( entry.registration) entry.registration.save() emails.send_registration_accepted_message(entry.registration, entry.payment) log_obj = entry.registration except Registration.DoesNotExist: try: emails.send_renewal_accepted_message(entry.renewal, entry.payment) log_obj = entry.renewal except Renewal.DoesNotExist: pass if log_obj: LogEntry.objects.log_action( user_id=user_id, content_type_id=get_content_type_for_model(log_obj).pk, object_id=log_obj.pk, object_repr=str(log_obj), action_flag=CHANGE, change_message="Change status to approved", ) entry.save() updated_entries.append(entry.pk) return len(updated_entries)
def _items_count(self, queryset: QuerySet) -> int: """ Since lists are mainly compatible with QuerySets and can be passed to paginator. We will first to try to use .count - and if not there will use a len """ try: # forcing to find queryset.count instead of list.count: return queryset.all().count() except AttributeError: return len(queryset)
def get_unrestricted_users(users: QuerySet, job) -> QuerySet: # If there is no job then there is nothing to compare users against and none are restricted. if not job: return users attribute_classes = [provider_task.provider.attribute_class for provider_task in job.data_provider_tasks.all()] unrestricted = users.all() for attribute_class in attribute_classes: if attribute_class: unrestricted = unrestricted.filter(attribute_classes=attribute_class) unrestricted = unrestricted.distinct() return unrestricted
def count_badges(user_badges: QuerySet, badge_class: str) -> int: """Count the user badges for a class. :param user_badges: The user badges. :param badge_class: The badge class. :return: The number of badges for the class. """ count = 0 for user_badge in user_badges.all(): if user_badge.badge.badge_class == badge_class: count += 1 return count
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs): cls.assert_is_proxy(qs) modified_qs = qs.all() if qs.order_by('related_model_name').distinct('related_model_name').count() == 1: related_model_name = qs.first().related_model_name modified_qs = modified_qs.annotate(**{ key: F('{}__{}'.format(related_model_name, value)) for key, value in kwargs.items() }) return modified_qs
def paginate(query: QuerySet, schema: BaseModel, params: Optional[AbstractParams] = None) -> AbstractPage: params = resolve_params(params) raw_params = params.to_raw_params() total = query.count() start = raw_params.limit * raw_params.offset end = start + raw_params.limit rows = query.all()[start:end] items = [schema.from_django(row) for row in rows] return create_page(items, total, params)
def check_and_associate_configurable_options(product: Product, options: QuerySet): with transaction.atomic(): # associate options with product if ProductConfigurableOption.objects.filter( product=product, configurable_option__in=options, ).count() < 3: ProductConfigurableOption.objects.filter(product=product).delete() for configurable_option in options.all(): ProductConfigurableOption.objects.create( product=product, configurable_option=configurable_option ) product.save()
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs): cls.assert_is_proxy(qs) modified_qs = qs.all() if qs.order_by('related_model_name').distinct( 'related_model_name').count() == 1: related_model_name = qs.first().related_model_name modified_qs = modified_qs.annotate( **{ key: F('{}__{}'.format(related_model_name, value)) for key, value in kwargs.items() }) return modified_qs
def auto_pay_invoice(recurring_payment_options: QuerySet, invoice_id: str) -> bool: # Method that will try to pay the remaining invoice balance if it's more than zero using one or more gateways # configured by client in his preferred order. charged_successfully = False for recurring_payment_option in recurring_payment_options.all( ).order_by('order'): if not charged_successfully: method_path = get_recurring_payment_method_path( gateway_name=recurring_payment_option.gateway_name) try: recur_payment_method = import_string(method_path) except ImportError: LOG.error( 'Could not get recurring payment method for {}'.format( recurring_payment_option.gateway_name)) else: charged_successfully = recur_payment_method( invoice_id=invoice_id) return charged_successfully
def reject_entries(user_id: int, queryset: QuerySet) -> int: """ Reject all entries in the queryset :param user_id: Id of the user executing this action :param queryset: queryset of entries :type queryset: Queryset[Entry] :return: number of updated rows :rtype: integer """ queryset = queryset.filter(status=Entry.STATUS_REVIEW) entries = list(queryset.all()) rows_updated = queryset.update(status=Entry.STATUS_REJECTED, updated_at=timezone.now()) for entry in entries: log_obj = None try: emails.send_registration_rejected_message(entry.registration) log_obj = entry.registration except Registration.DoesNotExist: try: emails.send_renewal_rejected_message(entry.renewal) log_obj = entry.renewal except Renewal.DoesNotExist: pass if log_obj: LogEntry.objects.log_action( user_id=user_id, content_type_id=get_content_type_for_model(log_obj).pk, object_id=log_obj.pk, object_repr=str(log_obj), action_flag=CHANGE, change_message="Changed status to rejected", ) return rows_updated
def delete_by_queryset(self, queryset: QuerySet) -> int: for entity in queryset.all(): self._message_publisher.send_entity_delete_message(entity) # return only the number of deleted objects return queryset.delete()[0]
def render_availabilities(self, value: QuerySet): return format_html_join("\n", "{} - {}<br>", ((availability.start_date.strftime('%d.%m.%Y'), availability.end_date.strftime('%d.%m.%Y')) for availability in value.all()))
def export_result(self, request, queryset: QuerySet): return redirect('export_result', id=queryset.all()[0].id)
def get_sum_of_task_sp(self, tasks: QuerySet): sum_of_sp = 0 for task in tasks.all(): sum_of_sp += task.storypoints return sum_of_sp
def list_all_values_from_relation(relation: QuerySet): return list(relation.all().values_list('name', flat=True))
def __init__(self, qs: QuerySet): self.media = Static(Static.MAIN).link self.caption = "Все сериалы" self.qs: Collection[models.Series] = qs.all()