8156742544

Committed 05 Mar 2024 01:03PM UTC coverage: 69.889% (-0.3%) from 70.212%

Build # 8156742544

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1054 from EsupPortail/develop

[DONE] Develop #3.5.1

Run Details

281 of 580 new or added lines in 23 files covered. (48.45%)

19 existing lines in 11 files now uncovered.

9911 of 14181 relevant lines covered (69.89%)

0.7 hits per line

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

54.31

/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
from django.views.decorators.csrf import csrf_exempt
from django.core.exceptions import SuspiciousOperation

import json
import os
import webvtt

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

MEDIA_ROOT = getattr(settings, "MEDIA_ROOT", "")


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)


@csrf_exempt
@api_view(["POST"])
def store_remote_encoded_video(request):
    """API view for storing remote encoded videos."""
    from .Encoding_video_model import Encoding_video_model
    from .encode import store_encoding_info, end_of_encoding

    video_id = request.GET.get("id", 0)
    video = get_object_or_404(Video, id=video_id)
    # start_store_remote_encoding_video(video_id)
    # check if video is encoding !!!
    data = json.loads(request.body.decode("utf-8"))
    if video.encoding_in_progress is False:
        raise SuspiciousOperation("video not encoding in progress")
    if str(video_id) != str(data["video_id"]):
        raise SuspiciousOperation(
            "different video id : %s - %s" % (video_id, data["video_id"])
        )
    print("Start the importing of the video: %s" % video_id)
    encoding_video = Encoding_video_model(
        video_id, data["video_path"], data["cut_start"], data["cut_end"]
    )
    encoding_video.start = data["start"]
    encoding_video.stop = data["stop"]
    final_video = store_encoding_info(video_id, encoding_video)
    end_of_encoding(final_video)
    return Response(VideoSerializer(instance=video, context={"request": request}).data)


@csrf_exempt
@api_view(["POST"])
def store_remote_transcripted_video(request):
    """API view for storing remote transcripted videos."""
    from .transcript import save_vtt_and_notify

    video_id = request.GET.get("id", 0)
    video = get_object_or_404(Video, id=video_id)
    # check if video is encoding !!!
    data = json.loads(request.body.decode("utf-8"))
    if str(video_id) != str(data["video_id"]):
        raise SuspiciousOperation(
            "different video id : %s - %s" % (video_id, data["video_id"])
        )
    print("Start the import of transcription of the video: %s" % video_id)
    filename = os.path.basename(data["temp_vtt_file"])
    media_temp_dir = os.path.join(MEDIA_ROOT, "temp")
    filepath = os.path.join(media_temp_dir, filename)
    new_vtt = webvtt.read(filepath)
    save_vtt_and_notify(video, data["msg"], new_vtt)
    os.remove(filepath)
    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
11	from django.shortcuts import get_object_or_404	1✔
12	from django.views.decorators.csrf import csrf_exempt	1✔
13	from django.core.exceptions import SuspiciousOperation	1✔
14
15	import json	1✔
16	import os	1✔
17	import webvtt	1✔
18
19	USE_TRANSCRIPTION = getattr(settings, "USE_TRANSCRIPTION", False)	1✔
20	if USE_TRANSCRIPTION:	1✔
21	from pod.video_encode_transcript.transcript import start_transcript	×
22
23	MEDIA_ROOT = getattr(settings, "MEDIA_ROOT", "")	1✔
24
25
26	class VideoRenditionSerializer(serializers.HyperlinkedModelSerializer):	1✔
27	class Meta:	1✔
28	model = VideoRendition	1✔
29	fields = (	1✔
30	"id",
31	"url",
32	"resolution",
33	"video_bitrate",
34	"audio_bitrate",
35	"encode_mp4",
36	"sites",
37	)
38
39
40	class EncodingVideoSerializer(serializers.HyperlinkedModelSerializer):	1✔
41	"""Serializer for the EncodingVideo model."""
42
43	class Meta:	1✔
44	model = EncodingVideo	1✔
45	fields = (	1✔
46	"id",
47	"url",
48	"name",
49	"video",
50	"rendition",
51	"encoding_format",
52	"source_file",
53	"sites_all",
54	)
55
56
57	class EncodingAudioSerializer(serializers.HyperlinkedModelSerializer):	1✔
58	"""Serializer for the EncodingAudio model."""
59
60	class Meta:	1✔
61	model = EncodingAudio	1✔
62	fields = (	1✔
63	"id",
64	"url",
65	"name",
66	"video",
67	"encoding_format",
68	"source_file",
69	"sites_all",
70	)
71
72
73	class EncodingVideoViewSet(viewsets.ModelViewSet):	1✔
74	"""Viewset for EncodingVideo model."""
75
76	queryset = EncodingVideo.objects.all()	1✔
77	serializer_class = EncodingVideoSerializer	1✔
78	filter_fields = ("video",)	1✔
79
80	@action(detail=False, methods=["get"])	1✔
81	def video_encodedfiles(self, request):	1✔
82	"""Retrieve encoded video files."""
83	encoded_videos = EncodingVideoViewSet.filter_encoded_medias(	×
84	self.queryset, request
85	)
86	encoded_videos = sorted(encoded_videos, key=lambda x: x.height)	×
87	serializer = EncodingVideoSerializer(	×
88	encoded_videos, many=True, context={"request": request}
89	)
90	return Response(serializer.data)	×
91
92	@staticmethod	1✔
93	def filter_encoded_medias(queryset, request):	1✔
94	"""Filter encoded media files."""
95	encoded_audios = queryset	×
96	if request.GET.get("video"):	×
97	encoded_audios = encoded_audios.filter(video__id=request.GET.get("video"))	×
98	if request.GET.get("extension"):	×
99	encoded_audios = encoded_audios.filter(	×
100	source_file__iendswith=request.GET.get("extension")
101	)
102	return encoded_audios	×
103
104
105	class EncodingAudioViewSet(viewsets.ModelViewSet):	1✔
106	"""Viewset for EncodingAudio model."""
107
108	queryset = EncodingAudio.objects.all()	1✔
109	serializer_class = EncodingAudioSerializer	1✔
110	filter_fields = ("video",)	1✔
111
112	@action(detail=False, methods=["get"])	1✔
113	def audio_encodedfiles(self, request):	1✔
114	"""Retrieve encoded audio files."""
115	encoded_audios = EncodingVideoViewSet.filter_encoded_medias(	×
116	self.queryset, request
117	)
118	serializer = EncodingAudioSerializer(	×
119	encoded_audios, many=True, context={"request": request}
120	)
121	return Response(serializer.data)	×
122
123
124	class VideoRenditionViewSet(viewsets.ModelViewSet):	1✔
125	queryset = VideoRendition.objects.all()	1✔
126	serializer_class = VideoRenditionSerializer	1✔
127
128
129	class PlaylistVideoSerializer(serializers.HyperlinkedModelSerializer):	1✔
130	class Meta:	1✔
131	model = PlaylistVideo	1✔
132	fields = (	1✔
133	"id",
134	"url",
135	"name",
136	"video",
137	"encoding_format",
138	"source_file",
139	"sites_all",
140	)
141
142
143	class PlaylistVideoViewSet(viewsets.ModelViewSet):	1✔
144	queryset = PlaylistVideo.objects.all()	1✔
145	serializer_class = PlaylistVideoSerializer	1✔
146
147
148	@api_view(["GET"])	1✔
149	def launch_encode_view(request):	1✔
150	"""API view for launching video encoding."""
151	video = get_object_or_404(Video, slug=request.GET.get("slug"))	×
152	if (	×
153	video is not None
154	and (
155	not hasattr(video, "launch_encode") or getattr(video, "launch_encode") is True
156	)
157	and video.encoding_in_progress is False
158	):
159	video.launch_encode = True	×
160	video.save()	×
161	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×
162
163
164	@api_view(["GET"])	1✔
165	def launch_transcript_view(request):	1✔
166	"""API view for launching transcript."""
167	video = get_object_or_404(Video, slug=request.GET.get("slug"))	×
168	if video is not None and video.get_video_mp3():	×
169	start_transcript(video.id, threaded=True)	×
170	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×
171
172
173	@csrf_exempt	1✔
174	@api_view(["POST"])	1✔
175	def store_remote_encoded_video(request):	1✔
176	"""API view for storing remote encoded videos."""
NEW 177	from .Encoding_video_model import Encoding_video_model	×
NEW 178	from .encode import store_encoding_info, end_of_encoding	×
179
180	video_id = request.GET.get("id", 0)	×
181	video = get_object_or_404(Video, id=video_id)	×
182	# start_store_remote_encoding_video(video_id)
183	# check if video is encoding !!!
NEW 184	data = json.loads(request.body.decode("utf-8"))	×
NEW 185	if video.encoding_in_progress is False:	×
NEW 186	raise SuspiciousOperation("video not encoding in progress")	×
NEW 187	if str(video_id) != str(data["video_id"]):	×
NEW 188	raise SuspiciousOperation(	×
189	"different video id : %s - %s" % (video_id, data["video_id"])
190	)
NEW 191	print("Start the importing of the video: %s" % video_id)	×
NEW 192	encoding_video = Encoding_video_model(	×
193	video_id, data["video_path"], data["cut_start"], data["cut_end"]
194	)
NEW 195	encoding_video.start = data["start"]	×
NEW 196	encoding_video.stop = data["stop"]	×
NEW 197	final_video = store_encoding_info(video_id, encoding_video)	×
NEW 198	end_of_encoding(final_video)	×
NEW 199	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×
200
201
202	@csrf_exempt	1✔
203	@api_view(["POST"])	1✔
204	def store_remote_transcripted_video(request):	1✔
205	"""API view for storing remote transcripted videos."""
NEW 206	from .transcript import save_vtt_and_notify	×
207
NEW 208	video_id = request.GET.get("id", 0)	×
NEW 209	video = get_object_or_404(Video, id=video_id)	×
210	# check if video is encoding !!!
NEW 211	data = json.loads(request.body.decode("utf-8"))	×
NEW 212	if str(video_id) != str(data["video_id"]):	×
NEW 213	raise SuspiciousOperation(	×
214	"different video id : %s - %s" % (video_id, data["video_id"])
215	)
NEW 216	print("Start the import of transcription of the video: %s" % video_id)	×
NEW 217	filename = os.path.basename(data["temp_vtt_file"])	×
NEW 218	media_temp_dir = os.path.join(MEDIA_ROOT, "temp")	×
NEW 219	filepath = os.path.join(media_temp_dir, filename)	×
NEW 220	new_vtt = webvtt.read(filepath)	×
NEW 221	save_vtt_and_notify(video, data["msg"], new_vtt)	×
NEW 222	os.remove(filepath)	×
UNCOV 223	return Response(VideoSerializer(instance=video, context={"request": request}).data)	×

EsupPortail / Esup-Pod / 8156742544

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