class CompetitionFilter(filters.FilterSet):
"""customized filters for the CompetitionList class"""
from_achievement_date = filters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='gte')
to_achievement_date = filters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='lte')
min_distance_in_feet = filters.NumberFilter(field_name='distance_in_feet',
lookup_expr='gte')
max_distance_in_feet = filters.NumberFilter(field_name='distance_in_feet',
lookup_expr='lte')
drone_name = filters.AllValuesFilter(field_name='drone__name')
pilot_name = filters.AllValuesFilter(field_name='pilot__name')
class Meta:
"""model related to the filter set"""
model = Competition
# field names and filter names that we want to include
# in the filters
fields = [
'distance_in_feet',
'from_achievement_date',
'to_achievement_date',
'min_distance_in_feet',
'max_distance_in_feet',
# drone__name will be accessed as drone_name
'drone_name',
# pilot__name will be accessed as pilot_name
'pilot_name'
]
class CompetitionFilter(dfilters.FilterSet):
"""
Custom filter class for
for the competition API view classes
"""
from_achievement_date = dfilters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='gte')
to_achievement_date = dfilters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='lte')
min_distance_in_feet = dfilters.NumberFilter(field_name='distance_in_feet',
lookup_expr='gte')
max_distance_in_feet = dfilters.NumberFilter(field_name='distance_in_feet',
lookup_expr='lte')
drone_name = dfilters.AllValuesFilter(
field_name='drone__name') # drone.name field
pilot_name = dfilters.AllValuesFilter(
field_name='pilot__name') # pilot.name field
class Meta:
model = Competition
fields = (
'distance_in_feet',
'from_achievement_date',
'to_achievement_date',
'min_distance_in_feet',
'max_distance_in_feet',
# drone__name will be accessed as drone_name
'drone_name',
# pilot__name will be accessed as pilot_name
'pilot_name',
)
class PatientFilter(filters.FilterSet):
"""
Provides useful filtering options for the :class:`~django_dicom.models.patient.Patient`
class.
"""
born_after_date = filters.DateFilter("date_of_birth", lookup_expr="gte")
born_before_date = filters.DateFilter("date_of_birth", lookup_expr="lte")
name_prefix = filters.AllValuesFilter("name_prefix")
sex = filters.ChoiceFilter("sex", choices=Sex.choices())
uid = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
given_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
middle_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
family_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
name_suffix = filters.AllValuesFilter("name_suffix")
study__id = filters.NumberFilter(method="filter_by_study")
class Meta:
model = Patient
fields = (
"id",
"uid",
"born_after_date",
"born_before_date",
"name_prefix",
"given_name",
"middle_name",
"family_name",
"name_suffix",
)
def filter_by_study(self, queryset, name, value):
if not value:
return queryset
series = Series.objects.filter(study__id=value)
patient_ids = set(series.values_list("patient", flat=True))
return queryset.filter(id__in=patient_ids)
class UserFilter(filters.FilterSet):
"""
Provides useful filtering options for the
:class:`~accounts.models.user.User` model.
"""
username = filters.LookupChoiceFilter(
lookup_choices=DEFUALT_LOOKUP_CHOICES)
first_name = filters.LookupChoiceFilter(
lookup_choices=DEFUALT_LOOKUP_CHOICES)
last_name = filters.LookupChoiceFilter(
lookup_choices=DEFUALT_LOOKUP_CHOICES)
email = filters.LookupChoiceFilter(lookup_choices=DEFUALT_LOOKUP_CHOICES)
institute = filters.AllValuesFilter(field_name="profile__institute")
class Meta:
model = User
fields = (
"id",
"username",
"first_name",
"last_name",
"email",
"institute",
"study",
)
class PlayerScoreFilter(filters.FilterSet):
min_score = filters.NumberFilter(field_name='score', lookup_expr='gte')
max_score = filters.NumberFilter(field_name='score', lookup_expr='lte')
from_score_date = filters.DateTimeFilter(field_name='score_date',
lookup_expr='gte')
to_score_date = filters.DateTimeFilter(field_name='score_date',
lookup_expr='lte')
player_name = filters.AllValuesFilter(field_name='player__name')
game_name = filters.AllValuesFilter(field_name='game__name')
class Meta:
model = PlayerScore
fields = ('score', 'from_score_date', 'to_score_date', 'min_score', 'max_score',\
# player__name will be accessed as player_name
'player_name',\
# game__name will be accessed as game_name
'game_name',
)
class ProfilesFilter(dfilters.FilterSet):
"""
profiles username filter class for
for the Profile model
"""
username = dfilters.AllValuesFilter(
field_name='user__username') # user.username field
class Meta:
model = Profile
fields = ('username', )
class PatientFilter(filters.FilterSet):
"""
Provides useful filtering options for the :class:`~django_dicom.models.patient.Patient`
class.
"""
born_after_date = filters.DateFilter("date_of_birth", lookup_expr="gte")
born_before_date = filters.DateFilter("date_of_birth", lookup_expr="lte")
name_prefix = filters.AllValuesFilter("name_prefix")
given_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
middle_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
family_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
name_suffix = filters.AllValuesFilter("name_suffix")
class Meta:
model = Patient
fields = (
"id",
"uid",
"born_after_date",
"born_before_date",
"name_prefix",
"given_name",
"middle_name",
"family_name",
"name_suffix",
)
class OutputDefinitionFilter(filters.FilterSet):
"""
Provides useful filtering options for the
:class:`~django_analyses.models.output.definitions.output_definition.OutputDefinition`
model.
"""
output_specification = filters.AllValuesFilter("specification_set")
class Meta:
model = OutputDefinition
fields = "key", "output_specification"
class InputDefinitionFilter(filters.FilterSet):
"""
Provides useful filtering options for the
:class:`~django_analyses.models.input.definitions.input_definition.InputDefinition`
model.
"""
input_specification = filters.AllValuesFilter("specification_set")
class Meta:
model = InputDefinition
fields = "key", "required", "is_configuration", "input_specification"
class ScanFilter(filters.FilterSet):
"""
Provides useful filtering options for the
:class:`~django_dicom.models.scan.Scan` class.
"""
description = filters.LookupChoiceFilter(
"description", lookup_choices=LOOKUP_CHOICES,
)
number = filters.NumberFilter("number")
scan_time = filters.DateTimeFromToRangeFilter("time")
created = filters.DateTimeFromToRangeFilter("created")
institution_name = filters.AllValuesFilter("institution_name")
dicom_id_in = NumberInFilter(field_name="dicom__id", lookup_expr="in")
sequence_type = filters.MultipleChoiceFilter(
field_name="dicom__sequence_type",
# Exclude the null value choices because it doesn't seem to integrate
# well with DRF.
choices=SEQUENCE_TYPE_CHOICES[:-1],
# Create DRF compatible null filter.
null_value=None,
null_label="Unknown",
)
subject_id_number = filters.LookupChoiceFilter(
"session__subject__id_number", lookup_choices=LOOKUP_CHOICES,
)
subject_first_name = filters.LookupChoiceFilter(
"session__subject__first_name", lookup_choices=LOOKUP_CHOICES,
)
subject_last_name = filters.LookupChoiceFilter(
"session__subject__last_name", lookup_choices=LOOKUP_CHOICES,
)
study_groups = filters.ModelMultipleChoiceFilter(
queryset=Group.objects.all()
)
class Meta:
model = Scan
fields = (
"id",
"echo_time",
"inversion_time",
"repetition_time",
"is_updated_from_dicom",
"dicom__id",
"session",
)
class ExecucaoContratoFilter(filters.FilterSet):
year = filters.AllValuesFilter(field_name='year__year', empty_label=None)
category = filters.ModelChoiceFilter(
queryset=CategoriaContrato.objects.all(),
field_name='categoria',
empty_label='Todas categorias')
def __init__(self, data=None, queryset=None, *args, **kwargs):
super().__init__(data=data, queryset=queryset, *args, **kwargs)
if 'year' not in self.data:
ordered = queryset.order_by('-year__year')
year = ordered.values_list('year__year', flat=True).first()
data = self.data.copy()
data['year'] = year
self.data = data
class Meta:
model = ExecucaoContrato
fields = ['year', 'category']
class ScanFilter(filters.FilterSet):
"""
Provides useful filtering options for the :class:`~django_dicom.models.series.Series`
class.
"""
description = filters.LookupChoiceFilter(
"description",
lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
],
)
number = filters.NumberFilter("number")
sequence_type = filters.AllValuesMultipleFilter("sequence_type")
# spatial_resolution = filters.AllValuesFilter("spatial_resolution")
scan_time = filters.DateTimeFromToRangeFilter("time")
created = filters.DateTimeFromToRangeFilter("created")
institution_name = filters.AllValuesFilter("institution_name")
dicom_id_in = NumberInFilter(field_name="dicom__id", lookup_expr="in")
class Meta:
model = Scan
fields = (
"id",
"description",
"number",
"created",
"scan_time",
"echo_time",
"inversion_time",
"repetition_time",
"sequence_type",
# "spatial_resolution",
"institution_name",
"is_updated_from_dicom",
"dicom__id",
"subject",
)
class VariantFilter(df_filters.FilterSet):
gene = df_filters.ModelChoiceFilter(queryset=Gene.objects.all())
gene_symbol = df_filters.CharFilter(field_name='gene__symbol',
label='Gene Symbol')
name = df_filters.CharFilter(field_name='name')
description = df_filters.CharFilter(field_name='description')
so_name = df_filters.AllValuesFilter(field_name='so_name',
label='Sequence Ontology Name')
sources = df_filters.BaseInFilter(field_name='sources',
lookup_expr='contains')
in_svip = df_filters.BooleanFilter(label='Is SVIP Variant?',
method='filter_has_svipdata')
# noinspection PyMethodMayBeStatic
def filter_has_svipdata(self, queryset, name, value):
if value:
# we require the .distinct() here because we occasionally have multiple VariantInSVIP entries
# keyed to the same variant (although that's clearly not great), and this implicit join
# causes those variants to be repeated as many times as there are referring VinSVIP entries
return queryset.filter(variantinsvip__isnull=False).distinct()
# otherwise, return all the variants, svip data or not
return queryset
class SeriesFilter(filters.FilterSet):
"""
Provides filtering functionality for the
:class:`~django_dicom.views.series.SeriesViewSet`.
Available filters are:
* *id*: Primary key
* *uid*: Series Instance UID
* *patient_id*: Related :class:`~django_dicom.models.patient.Patient`
instance's primary key
* *study_uid*: Related :class:`~django_dicom.models.study.Study`
instance's :attr:`~django_dicom.models.study.Study.uid` value
* *study_description*: Related
:class:`~django_dicom.models.study.Study` instance's
:attr:`~django_dicom.models.study.Study.description` value
(in-icontains)
* *modality*: Any of the values defined in
:class:`~dicom_parser.utils.code_strings.modality.Modality`
* *description*: Series description value (contains, icontains, or
exact)
* *number*: Series number value
* *protocol_name*: Protocol name value (contains)
* *scanning_sequence*: Any combination of the values defined in
:class:`~dicom_parser.utils.code_strings.scanning_sequence.ScanningSequence`
* *sequence_variant*: Any combination of the values defined in
:class:`~dicom_parser.utils.code_strings.sequence_variant.SequenceVariant`
* *echo_time*: :attr:`~django_dicom.models.series.Series.echo_time`
value
* *inversion_time*:
:attr:`~django_dicom.models.series.Series.inversion_time` value
* *repetition_time*:
:attr:`~django_dicom.models.series.Series.repetition_time` value
* *flip_angle*: Any of the existing
:attr:`~django_dicom.models.series.Series.flip_angle` in the database
* *created_after_date*: Create after date
* *date*: Exact :attr:`~django_dicom.models.series.Series.date` value
* *created_before_date*: Create before date
* *created_after_time*: Create after time
* *created_before_time*: Create before time
* *manufacturer*: Any of the existing
:attr:`~django_dicom.models.series.Series.manufacturer` in the
database
* *manufacturer_model_name*: Any of the existing
:attr:`~django_dicom.models.series.Series.manufacturer_model_name` in
the database
* *device_serial_number*: Any of the existing
:attr:`~django_dicom.models.series.Series.device_serial_number` in
the database
* *institution_name*: Any of the existing
:attr:`~django_dicom.models.series.Series.institution_name` in the
database
* *pulse_sequence_name*:
:attr:`~django_dicom.models.series.Series.pulse_sequence_name` value
(in-icontains)
* *sequence_name*:
:attr:`~django_dicom.models.series.Series.sequence_name` value
(in-icontains)
"""
study_uid = filters.CharFilter("study__uid",
lookup_expr="exact",
label="Study UID")
study_description = CharInFilter(
field_name="study__description",
lookup_expr="in",
label="Study description icontains",
method=filter_in_string,
)
modality = filters.ChoiceFilter("modality", choices=Modality.choices())
description = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
protocol_name = filters.CharFilter("protocol_name", lookup_expr="contains")
scanning_sequence = filters.MultipleChoiceFilter(
"scanning_sequence",
choices=ScanningSequence.choices(),
conjoined=True,
method=filter_array,
)
sequence_variant = filters.MultipleChoiceFilter(
"sequence_variant",
choices=SequenceVariant.choices(),
conjoined=True,
method=filter_array,
)
flip_angle = filters.AllValuesFilter("flip_angle")
created_after_date = filters.DateFilter("date", lookup_expr="gte")
date = filters.DateFilter("date")
created_before_date = filters.DateFilter("date", lookup_expr="lte")
created_after_time = filters.TimeFilter("time", lookup_expr="gte")
created_before_time = filters.TimeFilter("time", lookup_expr="lte")
manufacturer = filters.AllValuesFilter("manufacturer")
manufacturer_model_name = filters.AllValuesFilter(
"manufacturer_model_name")
magnetic_field_strength = filters.AllValuesFilter(
"magnetic_field_strength")
device_serial_number = filters.AllValuesFilter("device_serial_number")
institution_name = filters.AllValuesFilter("institution_name")
pulse_sequence_name = CharInFilter(
field_name="pulse_sequence_name",
lookup_expr="icontains",
method=filter_in_string,
)
sequence_name = CharInFilter(
field_name="sequence_name",
lookup_expr="icontains",
method=filter_in_string,
)
pixel_spacing = filters.RangeFilter("pixel_spacing__0")
slice_thickness = filters.RangeFilter("slice_thickness")
repetition_time = filters.RangeFilter("repetition_time")
inversion_time = filters.RangeFilter("inversion_time")
echo_time = filters.RangeFilter("echo_time")
header_fields = filters.CharFilter("image", method=filter_header)
class Meta:
model = Series
fields = (
"id",
"uid",
"patient_id",
"study_uid",
"study_description",
"modality",
"description",
"protocol_name",
"number",
"created_after_date",
"created_before_date",
"created_after_time",
"created_before_time",
"echo_time",
"inversion_time",
"repetition_time",
"slice_thickness",
"pixel_spacing",
"scanning_sequence",
"sequence_variant",
"flip_angle",
"manufacturer",
"manufacturer_model_name",
"magnetic_field_strength",
"device_serial_number",
"institution_name",
"patient__id",
"pulse_sequence_name",
"sequence_name",
)
class BrandModelFilter(filters.FilterSet):
name = filters.AllValuesFilter('name')
class Meta:
model = ModelName
fields = ('brandname', 'name')
class SeriesFilter(filters.FilterSet):
"""
Provides useful filtering options for the :class:`~django_dicom.models.series.Series`
class.
"""
patient_uid = filters.CharFilter(
"patient__uid", lookup_expr="icontains", label="Patient ID contains"
)
study_uid = filters.CharFilter(
"study__uid", lookup_expr="contains", label="Study UID"
)
study_description = filters.CharFilter(
"study__description", lookup_expr="contains", label="Study description contains"
)
modality = filters.ChoiceFilter("modality", choices=Modality.choices())
description = filters.LookupChoiceFilter(
lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
]
)
protocol_name = filters.CharFilter("protocol_name", lookup_expr="contains")
scanning_sequence = filters.MultipleChoiceFilter(
"scanning_sequence",
choices=ScanningSequence.choices(),
conjoined=True,
method=filter_array,
)
sequence_variant = filters.MultipleChoiceFilter(
"sequence_variant",
choices=SequenceVariant.choices(),
conjoined=True,
method=filter_array,
)
flip_angle = filters.AllValuesFilter("flip_angle")
created_after_date = filters.DateFilter("date", lookup_expr="gte")
created_before_date = filters.DateFilter("date", lookup_expr="lte")
created_after_time = filters.DateFilter("time", lookup_expr="gte")
created_before_time = filters.DateFilter("time", lookup_expr="lte")
manufacturer = filters.AllValuesFilter("manufacturer")
manufacturer_model_name = filters.AllValuesFilter("manufacturer_model_name")
magnetic_field_strength = filters.AllValuesFilter("magnetic_field_strength")
device_serial_number = filters.AllValuesFilter("device_serial_number")
institution_name = filters.AllValuesFilter("institution_name")
class Meta:
model = Series
fields = (
"id",
"uid",
"patient_uid",
"study_uid",
"study_description",
"modality",
"description",
"protocol_name",
"number",
"created_after_date",
"created_before_date",
"created_after_time",
"created_before_time",
"echo_time",
"inversion_time",
"repetition_time",
"scanning_sequence",
"sequence_variant",
"flip_angle",
"manufacturer",
"manufacturer_model_name",
"magnetic_field_strength",
"device_serial_number",
"institution_name",
)
class PatientFilter(filters.FilterSet):
"""
Provides filtering functionality for the
:class:`~django_dicom.views.patient.PatientViewSet`.
Available filters are:
* *id*: Primary key
* *uid*: Patient UID (contains, icontains, or exact)
* *born_after_date*: Earliest date of birth
* *born_before_date*: Latest date of birth
* *name_prefix*: Any of the existing *name_prefix* values in the
database
* *given_name*: Given name value (contains, icontains, or exact)
* *middle_name*: Middle name value (contains, icontains, or exact)
* *family_name*: Family name value (contains, icontains, or exact)
* *name_suffix*: Any of the existing *name_prefix* values in the
database
* *sex*: Any of the sex options defined in the
:class:`~dicom_parser.utils.code_strings.sex.Sex`
:class:`~enum.Enum`
* *study__id*: Related :class:`~django_dicom.models.study.Study` ID
"""
born_after_date = filters.DateFilter("date_of_birth", lookup_expr="gte")
born_before_date = filters.DateFilter("date_of_birth", lookup_expr="lte")
name_prefix = filters.AllValuesFilter("name_prefix")
sex = filters.ChoiceFilter("sex", choices=Sex.choices())
uid = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
given_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
middle_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
family_name = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
name_suffix = filters.AllValuesFilter("name_suffix")
study__id = filters.NumberFilter(method="filter_by_study")
class Meta:
model = Patient
fields = (
"id",
"uid",
"born_after_date",
"born_before_date",
"name_prefix",
"given_name",
"middle_name",
"family_name",
"name_suffix",
)
def filter_by_study(self, queryset: QuerySet, name: str,
value: int) -> QuerySet:
"""
Returns all :class:`~django_dicom.models.patient.Patient` instances
that have :class:`~django_dicom.models.series.Series` instances
belonging to the :class:`~django_dicom.models.study.Study` with the
specified *value* as primary key.
Used by
:attr:`~django_dicom.filters.patient_filter.PatientFilter.study__id`.
Parameters
----------
queryset : :class:`~django.db.models.query.QuerySet`
:class:`~django_dicom.models.patient.Patient` instances
name : str
Name of the queried filter field
value : int
:class:`~django_dicom.models.study.Study` primary key
Returns
-------
:class:`~django.db.models.query.QuerySet`
Filtered :class:`~django_dicom.models.patient.Patient` instances
"""
if not value:
return queryset
series = Series.objects.filter(study__id=value)
patient_ids = set(series.values_list("patient", flat=True))
return queryset.filter(id__in=patient_ids)
