6377635546

Committed 02 Oct 2023 08:21AM UTC coverage: 70.396% (-1.6%) from 71.99%

Build # 6377635546

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #900 from EsupPortail/develop

[DONE] #3.4.0

Run Details

1509 of 1509 new or added lines in 58 files covered. (100.0%)

9288 of 13194 relevant lines covered (70.4%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

67.09

/pod/video_encode_transcript/rest_views.py

from rest_framework import serializers, viewsets
from django.conf import settings
from .models import EncodingVideo, EncodingAudio, VideoRendition, PlaylistVideo
from pod.video.models import Video
from pod.video.rest_views import VideoSerializer

from rest_framework.decorators import action
from rest_framework.decorators import api_view
from rest_framework.response import Response
from django.shortcuts import get_object_or_404

USE_TRANSCRIPTION = getattr(settings, "USE_TRANSCRIPTION", False)
if USE_TRANSCRIPTION:
    from pod.video_encode_transcript.transcript import start_transcript


class VideoRenditionSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = VideoRendition
        fields = (
            "id",
            "url",
            "resolution",
            "video_bitrate",
            "audio_bitrate",
            "encode_mp4",
            "sites",
        )


class EncodingVideoSerializer(serializers.HyperlinkedModelSerializer):
    """Serializer for the EncodingVideo model."""

    class Meta:
        model = EncodingVideo
        fields = (
            "id",
            "url",
            "name",
            "video",
            "rendition",
            "encoding_format",
            "source_file",
            "sites_all",
        )


class EncodingAudioSerializer(serializers.HyperlinkedModelSerializer):
    """Serializer for the EncodingAudio model."""

    class Meta:
        model = EncodingAudio
        fields = (
            "id",
            "url",
            "name",
            "video",
            "encoding_format",
            "source_file",
            "sites_all",
        )


class EncodingVideoViewSet(viewsets.ModelViewSet):
    """Viewset for EncodingVideo model."""

    queryset = EncodingVideo.objects.all()
    serializer_class = EncodingVideoSerializer
    filter_fields = ("video",)

    @action(detail=False, methods=["get"])
    def video_encodedfiles(self, request):
        """Retrieve encoded video files."""
        encoded_videos = EncodingVideoViewSet.filter_encoded_medias(
            self.queryset, request
        )
        encoded_videos = sorted(encoded_videos, key=lambda x: x.height)
        serializer = EncodingVideoSerializer(
            encoded_videos, many=True, context={"request": request}
        )
        return Response(serializer.data)

    @staticmethod
    def filter_encoded_medias(queryset, request):
        """Filter encoded media files."""
        encoded_audios = queryset
        if request.GET.get("video"):
            encoded_audios = encoded_audios.filter(video__id=request.GET.get("video"))
        if request.GET.get("extension"):
            encoded_audios = encoded_audios.filter(
                source_file__iendswith=request.GET.get("extension")
            )
        return encoded_audios


class EncodingAudioViewSet(viewsets.ModelViewSet):
    """Viewset for EncodingAudio model."""

    queryset = EncodingAudio.objects.all()
    serializer_class = EncodingAudioSerializer
    filter_fields = ("video",)

    @action(detail=False, methods=["get"])
    def audio_encodedfiles(self, request):
        """Retrieve encoded audio files."""
        encoded_audios = EncodingVideoViewSet.filter_encoded_medias(
            self.queryset, request
        )
        serializer = EncodingAudioSerializer(
            encoded_audios, many=True, context={"request": request}
        )
        return Response(serializer.data)


class VideoRenditionViewSet(viewsets.ModelViewSet):
    queryset = VideoRendition.objects.all()
    serializer_class = VideoRenditionSerializer


class PlaylistVideoSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = PlaylistVideo
        fields = (
            "id",
            "url",
            "name",
            "video",
            "encoding_format",
            "source_file",
            "sites_all",
        )


class PlaylistVideoViewSet(viewsets.ModelViewSet):
    queryset = PlaylistVideo.objects.all()
    serializer_class = PlaylistVideoSerializer


@api_view(["GET"])
def launch_encode_view(request):
    """API view for launching video encoding."""
    video = get_object_or_404(Video, slug=request.GET.get("slug"))
    if (
        video is not None
        and (
            not hasattr(video, "launch_encode") or getattr(video, "launch_encode") is True
        )
        and video.encoding_in_progress is False
    ):
        video.launch_encode = True
        video.save()
    return Response(VideoSerializer(instance=video, context={"request": request}).data)


@api_view(["GET"])
def launch_transcript_view(request):
    """API view for launching transcript."""
    video = get_object_or_404(Video, slug=request.GET.get("slug"))
    if video is not None and video.get_video_mp3():
        start_transcript(video.id, threaded=True)
    return Response(VideoSerializer(instance=video, context={"request": request}).data)


@api_view(["GET"])
def store_remote_encoded_video(request):
    """API view for storing remote encoded videos."""
    video_id = request.GET.get("id", 0)
    video = get_object_or_404(Video, id=video_id)
    # start_store_remote_encoding_video(video_id)
    return Response(VideoSerializer(instance=video, context={"request": request}).data)

1	from rest_framework import serializers, viewsets	1✔
2	from django.conf import settings	1✔
3	from .models import EncodingVideo, EncodingAudio, VideoRendition, PlaylistVideo	1✔
4	from pod.video.models import Video	1✔
5	from pod.video.rest_views import VideoSerializer	1✔
6
7	from rest_framework.decorators import action	1✔
8	from rest_framework.decorators import api_view	1✔
9	from rest_framework.response import Response	1✔
10	from django.shortcuts import get_object_or_404	1✔
11
12	USE_TRANSCRIPTION = getattr(settings, "USE_TRANSCRIPTION", False)	1✔
13	if USE_TRANSCRIPTION:	1✔
14	from pod.video_encode_transcript.transcript import start_transcript	×
15
16
17	class VideoRenditionSerializer(serializers.HyperlinkedModelSerializer):	1✔
18	class Meta:	1✔
19	model = VideoRendition	1✔
20	fields = (	1✔
21	"id",
22	"url",
23	"resolution",
24	"video_bitrate",
25	"audio_bitrate",
26	"encode_mp4",
27	"sites",
28	)
29
30
31	class EncodingVideoSerializer(serializers.HyperlinkedModelSerializer):	1✔
32	"""Serializer for the EncodingVideo model."""
33
34	class Meta:	1✔
35	model = EncodingVideo	1✔
36	fields = (	1✔
37	"id",
38	"url",
39	"name",
40	"video",
41	"rendition",
42	"encoding_format",
43	"source_file",
44	"sites_all",
45	)
46
47
48	class EncodingAudioSerializer(serializers.HyperlinkedModelSerializer):	1✔
49	"""Serializer for the EncodingAudio model."""
50
51	class Meta:	1✔
52	model = EncodingAudio	1✔
53	fields = (	1✔
54	"id",
55	"url",
56	"name",
57	"video",
58	"encoding_format",
59	"source_file",
60	"sites_all",
61	)
62
63
64	class EncodingVideoViewSet(viewsets.ModelViewSet):	1✔
65	"""Viewset for EncodingVideo model."""
66
67	queryset = EncodingVideo.objects.all()	1✔
68	serializer_class = EncodingVideoSerializer	1✔
69	filter_fields = ("video",)	1✔
70
71	@action(detail=False, methods=["get"])	1✔
72	def video_encodedfiles(self, request):	1✔
73	"""Retrieve encoded video files."""
74	encoded_videos = EncodingVideoViewSet.filter_encoded_medias(	×
75	self.queryset, request
76	)
77	encoded_videos = sorted(encoded_videos, key=lambda x: x.height)	×
78	serializer = EncodingVideoSerializer(	×
79	encoded_videos, many=True, context={"request": request}
80	)
81	return Response(serializer.data)	×
82
83	@staticmethod	1✔
84	def filter_encoded_medias(queryset, request):	1✔
85	"""Filter encoded media files."""
86	encoded_audios = queryset	×
87	if request.GET.get("video"):	×
88	encoded_audios = encoded_audios.filter(video__id=request.GET.get("video"))	×
89	if request.GET.get("extension"):	×
90	encoded_audios = encoded_audios.filter(	×
91	source_file__iendswith=request.GET.get("extension")
92	)
93	return encoded_audios	×
94
95
96	class EncodingAudioViewSet(viewsets.ModelViewSet):	1✔
97	"""Viewset for EncodingAudio model."""
98
99	queryset = EncodingAudio.objects.all()	1✔
100	serializer_class = EncodingAudioSerializer	1✔
101	filter_fields = ("video",)	1✔
102
103	@action(detail=False, methods=["get"])	1✔
104	def audio_encodedfiles(self, request):	1✔
105	"""Retrieve encoded audio files."""
106	encoded_audios = EncodingVideoViewSet.filter_encoded_medias(	×
107	self.queryset, request
108	)
109	serializer = EncodingAudioSerializer(	×
110	encoded_audios, many=True, context={"request": request}
111	)
112	return Response(serializer.data)	×
113
114
115	class VideoRenditionViewSet(viewsets.ModelViewSet):	1✔
116	queryset = VideoRendition.objects.all()	1✔
117	serializer_class = VideoRenditionSerializer	1✔
118
119
120	class PlaylistVideoSerializer(serializers.HyperlinkedModelSerializer):	1✔
121	class Meta:	1✔
122	model = PlaylistVideo	1✔
123	fields = (	1✔
124	"id",
125	"url",
126	"name",
127	"video",
128	"encoding_format",
129	"source_file",
130	"sites_all",
131	)
132
133
134	class PlaylistVideoViewSet(viewsets.ModelViewSet):	1✔
135	queryset = PlaylistVideo.objects.all()	1✔
136	serializer_class = PlaylistVideoSerializer	1✔
137
138
139	@api_view(["GET"])	1✔
140	def launch_encode_view(request):	1✔
141	"""API view for launching video encoding."""
142	video = get_object_or_404(Video, slug=request.GET.get("slug"))	×
143	if (	×
144	video is not None
145	and (
146	not hasattr(video, "launch_encode") or getattr(video, "launch_encode") is True
147	)
148	and video.encoding_in_progress is False
149	):
150	video.launch_encode = True	×
151	video.save()	×
152	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×
153
154
155	@api_view(["GET"])	1✔
156	def launch_transcript_view(request):	1✔
157	"""API view for launching transcript."""
158	video = get_object_or_404(Video, slug=request.GET.get("slug"))	×
159	if video is not None and video.get_video_mp3():	×
160	start_transcript(video.id, threaded=True)	×
161	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×
162
163
164	@api_view(["GET"])	1✔
165	def store_remote_encoded_video(request):	1✔
166	"""API view for storing remote encoded videos."""
167	video_id = request.GET.get("id", 0)	×
168	video = get_object_or_404(Video, id=video_id)	×
169	# start_store_remote_encoding_video(video_id)
170	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×

EsupPortail / Esup-Pod / 6377635546

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous