13949252874

Committed 19 Mar 2025 02:37PM UTC coverage: 70.105%. First build

Build # 13949252874

Build Type

Pull #1280

github

Committed by

web-flow

Commit Message

Merge 3731eaee5 into 749de494a

Pull Request Pull Request #1280: Replace credit_videofile by credit_video_dir

Run Details

74 of 96 new or added lines in 11 files covered. (77.08%)

11983 of 17093 relevant lines covered (70.1%)

0.7 hits per line

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

55.73

/pod/video_encode_transcript/rest_views.py

from django.conf import settings
from .models import EncodingVideo, EncodingAudio, VideoRendition, PlaylistVideo
from pod.video.models import Video
from pod.recorder.models import Recording
from pod.video.rest_views import VideoSerializer

from rest_framework import serializers, viewsets
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 logging
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", "")

DEBUG = getattr(settings, "DEBUG", True)
logger = logging.getLogger(__name__)
if DEBUG:
    logger.setLevel(logging.DEBUG)


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
    filterset_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
    filterset_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):
    """View API 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):
    """View API 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):
    """View API 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)
    logger.info("Start importing encoding data for video: %s" % video_id)
    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 being encoded.")
    if str(video_id) != str(data["video_id"]):
        raise SuspiciousOperation(
            "Different video id: %s - %s" % (video_id, data["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_encoded_video_studio(request):
    from .encode import store_encoding_studio_info

    recording_id = request.GET.get("recording_id", 0)
    get_object_or_404(Recording, id=recording_id)
    data = json.loads(request.body.decode("utf-8"))
    store_encoding_studio_info(recording_id, data["video_output"], data["msg"])
    return Response("ok")


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

EsupPortail / Esup-Pod / 13949252874

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