views.py

class MeasurementQuery(APIView):
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    permission_classes = [IsAuthenticated]

    def get(
        self,
        request: Request,
        ra_deg: float,
        dec_deg: float,
        image_id: int,
        radius_deg: float,
    ) -> FileResponse:
        """Return a DS9/JS9 region file for all Measurement objects for a given cone search
        on an Image. Optionally highlight sources based on a Measurement or Source ID.

        Args:
            request: Django HTTPRequest. Supports 4 URL GET parameters:
                - selection_model: either "measurement" or "source" (defaults to "measurement").
                - selection_id: the id for the given `selection_model`.
                - run_id: (optional) only return measurements for sources with the given pipeline
                    run id (defaults to None).
                - no_forced: (optional) If true, exclude forced-photometry measurements (defaults
                    to False).
                Measurement objects that match the given selection criterion will be
                highlighted. e.g. ?selection_model=measurement&selection_id=100 will highlight
                the Measurement object with id=100. ?selection_model=source&selection_id=5
                will highlight all Measurement objects associated with the Source object with
                id=5.
            ra_deg: Cone search RA in decimal degrees.
            dec_deg: Cone search Dec in decimal degrees.
            image_id: Primary key (id) of the Image object to search.
            radius_deg: Cone search radius in decimal degrees.

        Returns:
            FileResponse: Django FileReponse containing a DS9/JS9 region file.
        """
        columns = ["id", "name", "ra", "dec", "bmaj", "bmin", "pa", "forced", "source", "source__name"]
        selection_model = request.GET.get("selection_model", "measurement")
        selection_id = request.GET.get("selection_id", None)
        run_id = request.GET.get("run_id", None)
        no_forced = request.GET.get("forced", False)

        # validate selection query params
        if selection_id is not None:
            if selection_model not in ("measurement", "source"):
                raise Http404("GET param selection_model must be either 'measurement' or 'source'.")
            if selection_model == "measurement":
                selection_attr = "id"
                selection_name = "name"
            else:
                selection_attr = selection_model
                selection_name = "source__name"
            try:
                selection_id = int(selection_id)
            except ValueError:
                raise Http404("GET param selection_id must be an integer.")

        measurements = (
            Measurement.objects.filter(image=image_id)
            .cone_search(ra_deg, dec_deg, radius_deg)
            .values(*columns, __name=F(selection_name))
        )
        if run_id:
            measurements = measurements.filter(source__run__id=run_id)
        if no_forced:
            measurements = measurements.filter(forced=False)
        measurement_region_file = io.StringIO()
        for meas in measurements:
            if selection_id is not None:
                color = "#FF0000" if meas[selection_attr] == selection_id else "#0000FF"
            shape = (
                f"ellipse({meas['ra']}d, {meas['dec']}d, {meas['bmaj']}\", {meas['bmin']}\", "
                f"{meas['pa']+90+180}d)"
            )
            properties: Dict[str, Any] = {
                "color": color,
                "data": {
                    "text": f"{selection_model} ID: {meas[selection_attr]}",
                    "link": reverse(f"vast_pipeline:{selection_model}_detail", args=[selection_id]),
                }
            }
            if meas["forced"]:
                properties.update(strokeDashArray=[3, 2])
            region = f"{shape} {json.dumps(properties)}\n"
            measurement_region_file.write(region)
        measurement_region_file.seek(0)
        f = io.BytesIO(bytes(measurement_region_file.read(), encoding="utf8"))
        response = FileResponse(
            f,
            as_attachment=False,
            filename=f"image-{image_id}_{ra_deg:.5f}_{dec_deg:+.5f}_radius-{radius_deg:.3f}.reg",
        )
        return response

class RawImageListSet(ViewSet):
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    permission_classes = [IsAuthenticated]

    @staticmethod
    def gen_title_data_tokens(list_of_paths):
        '''
        generate a dataframe with extra columns for HTML tags title
        and data-tokens to generate something like:
        <option title={{title}} data-tokens={{datatokens}}>{{path}}</option>
        this assume a path like this:
        EPOCH06x/COMBINED/STOKESI_SELAVY/VAST_2118-06A.EPOCH06x.I.selavy.components.txt
        For the following dataframe columns
                                                     path
        EPOCH06x/COMBINED/STOKESI_SELAVY/VAST_2118-06A...
                                                 title
        VAST_2118-06A.EPOCH06x.I.selavy.components.txt
                                               datatokens
        EPOCH06x VAST_2118-06A.EPOCH06x.I.selavy.compo...
        '''
        df = pd.DataFrame(list_of_paths, columns=['path'])
        df = df.sort_values('path')
        df['title'] = df['path'].str.split(pat=os.sep).str.get(-1)
        df['datatokens'] = (
            df['path'].str.split(pat=os.sep).str.get(0)
            .str.cat(df['title'], sep=' ')
        )

        return df.to_dict(orient='records')

    def list(self, request):
        # generate the folders path regex, e.g. /path/to/images/**/*.fits
        # first generate the list of main subfolders, e.g. [EPOCH01, ... ]
        img_root = settings.RAW_IMAGE_DIR
        if not os.path.exists(img_root):
            msg = 'Raw image folder does not exists'
            messages.error(request, msg)
            raise Http404(msg)

        img_subfolders_gen = filter(
            lambda x: os.path.isdir(os.path.join(img_root, x)),
            os.listdir(img_root)
        )
        img_subfolders1, img_subfolders2 = tee(img_subfolders_gen)
        img_regex_list = list(map(
            lambda x: os.path.join(img_root, x, '**' + os.sep + '*.fits'),
            img_subfolders1
        ))
        selavy_regex_list = list(map(
            lambda x: os.path.join(img_root, x, '**' + os.sep + '*.txt'),
            img_subfolders2
        ))
        # add home directory user data for user and jupyter-user (user = github name)
        req_user = request.user.username
        for user in [f'{req_user}', f'jupyter-{req_user}']:
            if settings.HOME_DATA_ROOT is not None:
                user_home_data = os.path.join(
                    settings.HOME_DATA_ROOT, user, settings.HOME_DATA_DIR
                )
            else:
                user_home_data = os.path.join(
                    os.path.expanduser(f'~{user}'), settings.HOME_DATA_DIR
                )
            if settings.HOME_DATA_DIR and os.path.exists(user_home_data):
                img_regex_list.append(os.path.join(user_home_data, '**' + os.sep + '*.fits'))
                selavy_regex_list.append(os.path.join(user_home_data, '**' + os.sep + '*.txt'))

        # generate raw image list in parallel
        dask_list = db.from_sequence(img_regex_list)
        fits_files = (
            dask_list.map(lambda x: glob(x, recursive=True))
            .flatten()
            .compute()
        )
        if not fits_files:
            messages.info(request, 'no fits files found')

        # generate raw image list in parallel
        dask_list = db.from_sequence(selavy_regex_list)
        selavy_files = (
            dask_list.map(lambda x: glob(x, recursive=True))
            .flatten()
            .compute()
        )
        if not fits_files:
            messages.info(request, 'no selavy files found')

        # generate response datastructure
        data = {
            'fits': self.gen_title_data_tokens(fits_files),
            'selavy': self.gen_title_data_tokens(selavy_files)
        }
        serializer = RawImageSelavyListSerializer(data)

        return Response(serializer.data)

class RunViewSet(ModelViewSet):
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    permission_classes = [IsAuthenticated]
    queryset = Run.objects.all()
    serializer_class = RunSerializer

    @rest_framework.decorators.action(detail=True, methods=['get'])
    def images(self, request, pk=None):
        qs = Image.objects.filter(run__id=pk).order_by('id')
        qs = self.filter_queryset(qs)
        page = self.paginate_queryset(qs)
        if page is not None:
            serializer = ImageSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = ImageSerializer(qs, many=True)
        return Response(serializer.data)

    @rest_framework.decorators.action(detail=True, methods=['get'])
    def measurements(self, request, pk=None):
        qs = Measurement.objects.filter(image__run__in=[pk]).order_by('id')
        qs = self.filter_queryset(qs)
        page = self.paginate_queryset(qs)
        if page is not None:
            serializer = MeasurementSerializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = MeasurementSerializer(qs, many=True)
        return Response(serializer.data)

    @rest_framework.decorators.action(detail=True, methods=['post'])
    def run(
        self, request: Request, pk: Optional[int] = None
    ) -> HttpResponseRedirect:
        """
        Launches a pipeline run using a Django Q cluster. Includes a check
        on ownership or admin stataus of the user to make sure processing
        is allowed.

        Args:
            request: Django REST Framework request object.
            pk: Run object primary key. Defaults to None.

        Raises:
            Http404: if a Source with the given `pk` cannot be found.

        Returns:
            Response: Returns to the orignal request page (the pipeline run
                detail).
        """
        if not pk:
            messages.error(
                request,
                'Error in config write: Run pk parameter null or not passed'
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            p_run = get_object_or_404(self.queryset, pk=pk)
        except Exception as e:
            messages.error(request, f'Error in config write: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # make sure that only the run creator or an admin can request the run
        # to be processed.
        if p_run.user != request.user and not request.user.is_staff:
            msg = 'You do not have permission to process this pipeline run!'
            messages.error(request, msg)
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # check that it's not already running or queued
        if p_run.status in ["RUN", "QUE", "RES"]:
            msg = (
                f'{p_run.name} is already running, queued or restoring.'
                ' Please wait for the run to complete before trying to'
                ' submit again.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        if Run.objects.check_max_runs(settings.MAX_PIPELINE_RUNS):
            msg = (
                'The maximum number of simultaneous pipeline runs has been'
                f' reached ({settings.MAX_PIPELINE_RUNS})! Please try again'
                ' when other jobs have finished.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        prev_status = p_run.status
        try:
            with transaction.atomic():
                p_run.status = 'QUE'
                p_run.save()

            debug_flag = True if request.POST.get('debug', None) else False
            full_rerun = True if request.POST.get('fullReRun', None) else False

            async_task(
                'vast_pipeline.management.commands.runpipeline.run_pipe',
                p_run.name, p_run.path, p_run, False, debug_flag,
                task_name=p_run.name, ack_failure=True, user=request.user,
                full_rerun=full_rerun, prev_ui_status=prev_status
            )
            msg = mark_safe(
                f'<b>{p_run.name}</b> successfully sent to the queue!<br><br>Refresh the'
                ' page to check the status.'
            )
            messages.success(
                request,
                msg
            )
        except Exception as e:
            with transaction.atomic():
                p_run.status = 'ERR'
                p_run.save()
            messages.error(request, f'Error in running pipeline: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        return HttpResponseRedirect(
            reverse('vast_pipeline:run_detail', args=[p_run.id])
        )

    @rest_framework.decorators.action(detail=True, methods=['post'])
    def restore(
        self, request: Request, pk: Optional[int] = None
    ) -> HttpResponseRedirect:
        """
        Launches a restore pipeline run using a Django Q cluster. Includes a
        check on ownership or admin status of the user to make sure
        processing is allowed.

        Args:
            request: Django REST Framework request object.
            pk: Run object primary key. Defaults to None.

        Raises:
            Http404: if a Source with the given `pk` cannot be found.

        Returns:
            Response: Returns to the orignal request page (the pipeline run
                detail).
        """
        if not pk:
            messages.error(
                request,
                'Error in config write: Run pk parameter null or not passed'
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            p_run = get_object_or_404(self.queryset, pk=pk)
        except Exception as e:
            messages.error(request, f'Error in run fetch: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # make sure that only the run creator or an admin can request the run
        # to be processed.
        if p_run.user != request.user and not request.user.is_staff:
            msg = 'You do not have permission to process this pipeline run!'
            messages.error(request, msg)
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # check that it's not already running or queued
        if p_run.status in ["RUN", "QUE", "RES", "INI"]:
            msg = (
                f'{p_run.name} is already running, queued, restoring or is '
                'only initialised. It cannot be restored at this time.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        if Run.objects.check_max_runs(settings.MAX_PIPELINE_RUNS):
            msg = (
                'The maximum number of simultaneous pipeline runs has been'
                f' reached ({settings.MAX_PIPELINE_RUNS})! Please try again'
                ' when other jobs have finished.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        prev_status = p_run.status
        try:
            debug_flag = 3 if request.POST.get('restoreDebug', None) else 1

            async_task(
                'django.core.management.call_command',
                'restorepiperun',
                p_run.path,
                no_confirm=True,
                verbosity=debug_flag
            )

            msg = mark_safe(
                f'Restore <b>{p_run.name}</b> successfully sent to the queue!<br><br>Refresh the'
                ' page to check the status.'
            )
            messages.success(
                request,
                msg
            )
        except Exception as e:
            with transaction.atomic():
                p_run.status = 'ERR'
                p_run.save()
            messages.error(request, f'Error in restoring run: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        return HttpResponseRedirect(
            reverse('vast_pipeline:run_detail', args=[p_run.id])
        )

    @rest_framework.decorators.action(detail=True, methods=['post'])
    def delete(
        self, request: Request, pk: Optional[int] = None
    ) -> HttpResponseRedirect:
        """
        Launches the remove pipeline run using a Django Q cluster. Includes a
        check on ownership or admin status of the user to make sure
        deletion is allowed.

        Args:
            request (Request): Django REST Framework request object.
            pk (int, optional): Run object primary key. Defaults to None.

        Raises:
            Http404: if a Source with the given `pk` cannot be found.

        Returns:
            Response: Returns to the run index page (list of pipeline runs).
        """
        if not pk:
            messages.error(
                request,
                'Error in config write: Run pk parameter null or not passed'
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            p_run = get_object_or_404(self.queryset, pk=pk)
        except Exception as e:
            messages.error(request, f'Error in run fetch: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # make sure that only the run creator or an admin can request the run
        # to be processed.
        if p_run.user != request.user and not request.user.is_staff:
            msg = 'You do not have permission to process this pipeline run!'
            messages.error(request, msg)
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # check that it's not already running or queued
        if p_run.status in ["RUN", "QUE", "RES"]:
            msg = (
                f'{p_run.name} is already running, queued or restoring. '
                'It cannot be deleted at this time.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            async_task(
                'django.core.management.call_command',
                'clearpiperun',
                p_run.path,
                remove_all=True,
            )

            msg = mark_safe(
                f'Delete <b>{p_run.name}</b> successfully requested!<br><br>'
                ' Refresh the Pipeline Runs page for the deletion to take effect.'
            )
            messages.success(
                request,
                msg
            )
        except Exception as e:
            with transaction.atomic():
                p_run.status = 'ERR'
                p_run.save()
            messages.error(request, f'Error in deleting run: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        return HttpResponseRedirect(
            reverse('vast_pipeline:run_index')
        )

    @rest_framework.decorators.action(detail=True, methods=['post'])
    def genarrow(
        self, request: Request, pk: Optional[int] = None
    ) ->HttpResponseRedirect:
        """
        Launches the create arrow files process for a pipeline run using
        a Django Q cluster. Includes a check on ownership or admin status of
        the user to make sure the creation is allowed.

        Args:
            request: Django REST Framework request object.
            pk: Run object primary key. Defaults to None.

        Raises:
            Http404: if a Source with the given `pk` cannot be found.

        Returns:
            Response: Returns to the orignal request page (the pipeline run
                detail).
        """
        if not pk:
            messages.error(
                request,
                'Error in config write: Run pk parameter null or not passed'
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            p_run = get_object_or_404(self.queryset, pk=pk)
        except Exception as e:
            messages.error(request, f'Error in run fetch: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # make sure that only the run creator or an admin can request the run
        # to be processed.
        if p_run.user != request.user and not request.user.is_staff:
            msg = 'You do not have permission to process this pipeline run!'
            messages.error(request, msg)
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        # check that it's not already running or queued
        if p_run.status != "END":
            msg = (
                f'{p_run.name} has not completed successfully.'
                ' The arrow files can only be generated after the run is'
                ' successful.'
            )
            messages.error(
                request,
                msg
            )
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        try:
            overwrite_flag = True if request.POST.get('arrowOverwrite', None) else False

            async_task(
                'django.core.management.call_command',
                'createmeasarrow',
                p_run.path,
                overwrite=overwrite_flag,
                verbosity=3
            )

            msg = mark_safe(
                f'Generate the arrow files for <b>{p_run.name}</b> successfully requested!<br><br>'
                ' Refresh the page and check the generate arrow log output for the status of the process.'
            )
            messages.success(
                request,
                msg
            )
        except Exception as e:
            with transaction.atomic():
                p_run.status = 'ERR'
                p_run.save()
            messages.error(request, f'Error in deleting run: {e}')
            return HttpResponseRedirect(request.META.get('HTTP_REFERER'))

        return HttpResponseRedirect(
            reverse('vast_pipeline:run_detail', args=[p_run.id])
        )

class SourcePlotsSet(ViewSet):
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    permission_classes = [IsAuthenticated]

    @rest_framework.decorators.action(methods=['get'], detail=True)
    def lightcurve(self, request: Request, pk: int = None) -> Response:
        """Create lightcurve and 2-epoch metric graph plots for a source.

        Args:
            request (Request): Django REST Framework request object.
            pk (int, optional): Source object primary key. Defaults to None.

        Raises:
            Http404: if a Source with the given `pk` cannot be found.

        Returns:
            Response: Django REST Framework response object containing the Bokeh plot in
                JSON format to be embedded in the HTML template.
        """
        try:
            source = Source.objects.get(pk=pk)
        except Source.DoesNotExist:
            raise Http404
        # TODO raster plots version for Slack posts
        use_peak_flux = request.query_params.get("peak_flux", "true").lower() == "true"
        plot_document = plot_lightcurve(source, use_peak_flux=use_peak_flux)
        return Response(json_item(plot_document))

    @rest_framework.decorators.action(methods=['get'], detail=False)
    def etavplot(self, request: Request) -> Response:
        """Create the eta-V plot.

        Args:
            request (Request): Django REST Framework request object.

        Raises:
            Http404: if no sources are found.

        Returns:
            Response: Django REST Framework response object containing the Bokeh plot in
                JSON format to be embedded in the HTML template.
        """
        source_query_result_id_list = request.session.get("source_query_result_ids", [])
        try:
            source = Source.objects.filter(pk__in=source_query_result_id_list)
        except Source.DoesNotExist:
            raise Http404
        # TODO raster plots version for Slack posts
        use_peak_flux = request.query_params.get("peak_flux", "true").lower() == "true"

        eta_sigma = float(request.query_params.get("eta_sigma", 3.0))
        v_sigma = float(request.query_params.get("v_sigma", 3.0))

        plot_document = plot_eta_v_bokeh(
            source, eta_sigma=eta_sigma, v_sigma=v_sigma, use_peak_flux=use_peak_flux)
        return Response(json_item(plot_document))

class SourceViewSet(ModelViewSet):
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    permission_classes = [IsAuthenticated]
    serializer_class = SourceSerializer

    def get_queryset(self):
        qs = Source.objects.all().filter(run__status='END')

        radius_conversions = {
            "arcsec": 3600.,
            "arcmin": 60.,
            "deg": 1.
        }

        qry_dict = {}
        p_run = self.request.query_params.get('run')
        if p_run:
            qry_dict['run__name'] = p_run

        flux_qry_flds = [
            'avg_flux_int',
            'avg_flux_peak',
            'min_flux_peak',
            'max_flux_peak',
            'min_flux_int',
            'max_flux_int',
            'min_flux_peak_isl_ratio',
            'min_flux_int_isl_ratio',
            'v_int',
            'v_peak',
            'eta_int',
            'eta_peak',
            'vs_abs_significant_max_int',
            'vs_abs_significant_max_peak',
            'm_abs_significant_max_int',
            'm_abs_significant_max_peak',
            'n_meas',
            'n_meas_sel',
            'n_meas_forced',
            'n_rel',
            'new_high_sigma',
            'avg_compactness',
            'min_snr',
            'max_snr',
            'n_neighbour_dist',
            'source_selection',
            'source_selection_type'
        ]

        neighbour_unit = self.request.query_params.get('NeighbourUnit')

        for fld in flux_qry_flds:
            for limit in ['max', 'min']:
                val = self.request.query_params.get(limit + '_' + fld)
                if val:
                    ky = fld + '__lte' if limit == 'max' else fld + '__gte'
                    if fld == 'n_neighbour_dist':
                        val = float(val) / radius_conversions[neighbour_unit]
                    qry_dict[ky] = val

        measurements = self.request.query_params.get('meas')
        if measurements:
            qry_dict['measurements'] = measurements

        if 'source_selection' in self.request.query_params:
            selection_type = self.request.query_params['source_selection_type']
            selection: List[str] = (
                self.request.query_params['source_selection']
                .replace(" ", "")
                .replace("VAST", "")  # remove published source prefix if present
                .split(",")
            )
            if selection_type == 'name':
                qry_dict['name__in'] = selection
            else:
                try:
                    selection = [int(i) for i in selection]
                    qry_dict['id__in'] = selection
                except:
                    # this avoids an error on the check if the user has
                    # accidentally entered names with a 'id' selection type.
                    qry_dict['id'] = -1

        if 'newsrc' in self.request.query_params:
            qry_dict['new'] = True

        if 'no_siblings' in self.request.query_params:
            qry_dict['n_sibl'] = 0

        if 'tags_include' in self.request.query_params:
            qry_dict['tags'] = self.request.query_params['tags_include']

        if 'tags_exclude' in self.request.query_params:
            qs = qs.exclude(tags=self.request.query_params['tags_exclude'])

        if qry_dict:
            qs = qs.filter(**qry_dict)

        radius = self.request.query_params.get('radius')
        radiusUnit = self.request.query_params.get('radiusunit')
        coordsys = self.request.query_params.get('coordsys')
        coord_string = self.request.query_params.get('coord')
        wavg_ra, wavg_dec = None, None
        if coord_string:
            coord = parse_coord(coord_string, coord_frame=coordsys).transform_to("icrs")
            wavg_ra = coord.ra.deg
            wavg_dec = coord.dec.deg

        if None not in (wavg_ra, wavg_dec, radius):
            radius = float(radius) / radius_conversions[radiusUnit]
            qs = qs.cone_search(wavg_ra, wavg_dec, radius)

        return qs

    def list(self, request, *args, **kwargs):
        """Override the DRF ModelViewSet.list function to store the source ID order in the
        user session to retain the source order for source detail view next and previous
        button links. Then, call the original list function.
        """
        queryset = self.filter_queryset(self.get_queryset())
        self.request.session["source_query_result_ids"] = list(
            queryset.values_list("id", flat=True)
        )
        return super().list(request, *args, **kwargs)

    @rest_framework.decorators.action(detail=True, methods=['get'])
    def related(self, request, pk=None):
        qs = Source.objects.filter(related__id=pk).order_by('id')
        qs = self.filter_queryset(qs)
        page = self.paginate_queryset(qs)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)

        serializer = self.get_serializer(qs, many=True)
        return Response(serializer.data)