13964928276

Committed 20 Mar 2025 08:26AM UTC coverage: 70.106%. First build

Build # 13964928276

Build Type

Pull #1280

github

Committed by

web-flow

Commit Message

Merge a06fb2670 into 749de494a

Pull Request Pull Request #1280: Replace credit_videofile by credit_video_dir

Run Details

83 of 105 new or added lines in 12 files covered. (79.05%)

11984 of 17094 relevant lines covered (70.11%)

0.7 hits per line

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

38.46

/pod/video_encode_transcript/encoding_tasks.py

"""Esup-Pod encoding tasks."""

from celery import Celery
import logging
import requests

# call local settings directly
# no need to load pod application to send statement
try:
    from ..custom import settings_local
except ImportError:
    from .. import settings as settings_local

EMAIL_HOST = getattr(settings_local, "EMAIL_HOST", "")
DEFAULT_FROM_EMAIL = getattr(settings_local, "DEFAULT_FROM_EMAIL", "")
ADMINS = getattr(settings_local, "ADMINS", ())
DEBUG = getattr(settings_local, "DEBUG", True)
TEST_REMOTE_ENCODE = getattr(settings_local, "TEST_REMOTE_ENCODE", False)

admins_email = [ad[1] for ad in ADMINS]

logger = logging.getLogger(__name__)
if DEBUG:
    logger.setLevel(logging.DEBUG)

smtp_handler = logging.handlers.SMTPHandler(
    mailhost=EMAIL_HOST,
    fromaddr=DEFAULT_FROM_EMAIL,
    toaddrs=admins_email,
    subject="[POD ENCODING] Encoding Log Mail",
)
if not TEST_REMOTE_ENCODE:
    logger.addHandler(smtp_handler)

ENCODING_TRANSCODING_CELERY_BROKER_URL = getattr(
    settings_local, "ENCODING_TRANSCODING_CELERY_BROKER_URL", ""
)
POD_API_URL = getattr(settings_local, "POD_API_URL", "")
POD_API_TOKEN = getattr(settings_local, "POD_API_TOKEN", "")
encoding_app = Celery("encoding_tasks", broker=ENCODING_TRANSCODING_CELERY_BROKER_URL)
encoding_app.conf.task_routes = {
    "pod.video_encode_transcript.encoding_tasks.*": {"queue": "encoding"}
}


# celery -A pod.video_encode_transcript.encoding_tasks worker -l INFO -Q encoding
@encoding_app.task(bind=True)
def start_encoding_task(
    self, video_id, video_path, cut_start, cut_end, json_dressing, dressing_input
) -> None:
    """Start the encoding of the video."""
    logger.info("Start encoding of the video %s" % video_id)
    from .Encoding_video import Encoding_video

    logger.debug(
        "{video_id: %s, video_path: %s, cut_start: %s, cut_end: %s}"
        % (video_id, video_path, cut_start, cut_end)
    )
    encoding_video = Encoding_video(
        video_id, video_path, cut_start, cut_end, json_dressing, dressing_input
    )
    encoding_video.start_encode()
    logger.info("End encoding of the video %s" % video_id)
    Headers = {"Authorization": "Token %s" % POD_API_TOKEN}
    url = POD_API_URL.strip("/") + "/store_remote_encoded_video/?id=%s" % video_id
    data = {
        "start": encoding_video.start,
        "video_id": video_id,
        "video_path": video_path,
        "cut_start": cut_start,
        "cut_end": cut_end,
        "stop": encoding_video.stop,
        "json_dressing": json_dressing,
        "dressing_input": dressing_input,
    }
    msg = "Task id : %s\n" % self.request.id
    try:
        response = requests.post(url, json=data, headers=Headers)
        if response.status_code != 200:
            msg += "Calling store remote encoding error: {} {}".format(
                response.status_code, response.reason
            )
            logger.error(msg + "\n" + str(response.content))
        else:
            logger.info(msg + "Call importing encoding task ok")
    except (
        requests.exceptions.HTTPError,
        requests.exceptions.ConnectionError,
        requests.exceptions.InvalidURL,
        requests.exceptions.Timeout,
    ) as exception:
        msg += "Exception: {}".format(type(exception).__name__)
        msg += "\nException message: {}".format(exception)
        logger.error(msg)


@encoding_app.task
def start_studio_task(recording_id, video_output, videos, subtime, presenter) -> None:
    from .encoding_studio import start_encode_video_studio

    logger.info("Start the encoding studio of the video %s" % recording_id)
    msg = start_encode_video_studio(video_output, videos, subtime, presenter)
    logger.info("End of the encoding studio of the video %s" % recording_id)
    Headers = {"Authorization": "Token %s" % POD_API_TOKEN}
    url = (
        POD_API_URL.strip("/")
        + "/store_remote_encoded_video_studio/?recording_id=%s" % recording_id
    )
    data = {
        "video_output": video_output,
        "msg": msg,
    }
    try:
        response = requests.post(url, json=data, headers=Headers)
        if response.status_code != 200:
            msg = "Calling store remote encoding studio error: {} {}".format(
                response.status_code, response.reason
            )
            logger.error(msg + "\n" + str(response.content))
        else:
            logger.info("Call importing encoded studio task ok")
    except (
        requests.exceptions.HTTPError,
        requests.exceptions.ConnectionError,
        requests.exceptions.InvalidURL,
        requests.exceptions.Timeout,
    ) as exception:
        msg = "Exception: {}".format(type(exception).__name__)
        msg += "\nException message: {}".format(exception)
        logger.error(msg)

1	"""Esup-Pod encoding tasks."""
2
3	from celery import Celery	1✔
4	import logging	1✔
5	import requests	1✔
6
7	# call local settings directly
8	# no need to load pod application to send statement
9	try:	1✔
10	from ..custom import settings_local	1✔
11	except ImportError:	×
12	from .. import settings as settings_local	×
13
14	EMAIL_HOST = getattr(settings_local, "EMAIL_HOST", "")	1✔
15	DEFAULT_FROM_EMAIL = getattr(settings_local, "DEFAULT_FROM_EMAIL", "")	1✔
16	ADMINS = getattr(settings_local, "ADMINS", ())	1✔
17	DEBUG = getattr(settings_local, "DEBUG", True)	1✔
18	TEST_REMOTE_ENCODE = getattr(settings_local, "TEST_REMOTE_ENCODE", False)	1✔
19
20	admins_email = [ad[1] for ad in ADMINS]	1✔
21
22	logger = logging.getLogger(__name__)	1✔
23	if DEBUG:	1✔
24	logger.setLevel(logging.DEBUG)	1✔
25
26	smtp_handler = logging.handlers.SMTPHandler(	1✔
27	mailhost=EMAIL_HOST,
28	fromaddr=DEFAULT_FROM_EMAIL,
29	toaddrs=admins_email,
30	subject="[POD ENCODING] Encoding Log Mail",
31	)
32	if not TEST_REMOTE_ENCODE:	1✔
33	logger.addHandler(smtp_handler)	×
34
35	ENCODING_TRANSCODING_CELERY_BROKER_URL = getattr(	1✔
36	settings_local, "ENCODING_TRANSCODING_CELERY_BROKER_URL", ""
37	)
38	POD_API_URL = getattr(settings_local, "POD_API_URL", "")	1✔
39	POD_API_TOKEN = getattr(settings_local, "POD_API_TOKEN", "")	1✔
40	encoding_app = Celery("encoding_tasks", broker=ENCODING_TRANSCODING_CELERY_BROKER_URL)	1✔
41	encoding_app.conf.task_routes = {	1✔
42	"pod.video_encode_transcript.encoding_tasks.*": {"queue": "encoding"}
43	}
44
45
46	# celery -A pod.video_encode_transcript.encoding_tasks worker -l INFO -Q encoding
47	@encoding_app.task(bind=True)	1✔
48	def start_encoding_task(	1✔
49	self, video_id, video_path, cut_start, cut_end, json_dressing, dressing_input
50	) -> None:
51	"""Start the encoding of the video."""
NEW 52	logger.info("Start encoding of the video %s" % video_id)	×
53	from .Encoding_video import Encoding_video	×
54
NEW 55	logger.debug(	×
56	"{video_id: %s, video_path: %s, cut_start: %s, cut_end: %s}"
57	% (video_id, video_path, cut_start, cut_end)
58	)
59	encoding_video = Encoding_video(	×
60	video_id, video_path, cut_start, cut_end, json_dressing, dressing_input
61	)
62	encoding_video.start_encode()	×
NEW 63	logger.info("End encoding of the video %s" % video_id)	×
64	Headers = {"Authorization": "Token %s" % POD_API_TOKEN}	×
65	url = POD_API_URL.strip("/") + "/store_remote_encoded_video/?id=%s" % video_id	×
66	data = {	×
67	"start": encoding_video.start,
68	"video_id": video_id,
69	"video_path": video_path,
70	"cut_start": cut_start,
71	"cut_end": cut_end,
72	"stop": encoding_video.stop,
73	"json_dressing": json_dressing,
74	"dressing_input": dressing_input,
75	}
76	msg = "Task id : %s\n" % self.request.id	×
77	try:	×
78	response = requests.post(url, json=data, headers=Headers)	×
79	if response.status_code != 200:	×
80	msg += "Calling store remote encoding error: {} {}".format(	×
81	response.status_code, response.reason
82	)
83	logger.error(msg + "\n" + str(response.content))	×
84	else:
85	logger.info(msg + "Call importing encoding task ok")	×
86	except (	×
87	requests.exceptions.HTTPError,
88	requests.exceptions.ConnectionError,
89	requests.exceptions.InvalidURL,
90	requests.exceptions.Timeout,
91	) as exception:
92	msg += "Exception: {}".format(type(exception).__name__)	×
93	msg += "\nException message: {}".format(exception)	×
94	logger.error(msg)	×
95
96
97	@encoding_app.task	1✔
98	def start_studio_task(recording_id, video_output, videos, subtime, presenter) -> None:	1✔
99	from .encoding_studio import start_encode_video_studio	×
100
NEW 101	logger.info("Start the encoding studio of the video %s" % recording_id)	×
102	msg = start_encode_video_studio(video_output, videos, subtime, presenter)	×
NEW 103	logger.info("End of the encoding studio of the video %s" % recording_id)	×
104	Headers = {"Authorization": "Token %s" % POD_API_TOKEN}	×
105	url = (	×
106	POD_API_URL.strip("/")
107	+ "/store_remote_encoded_video_studio/?recording_id=%s" % recording_id
108	)
109	data = {	×
110	"video_output": video_output,
111	"msg": msg,
112	}
113	try:	×
114	response = requests.post(url, json=data, headers=Headers)	×
115	if response.status_code != 200:	×
116	msg = "Calling store remote encoding studio error: {} {}".format(	×
117	response.status_code, response.reason
118	)
119	logger.error(msg + "\n" + str(response.content))	×
120	else:
121	logger.info("Call importing encoded studio task ok")	×
122	except (	×
123	requests.exceptions.HTTPError,
124	requests.exceptions.ConnectionError,
125	requests.exceptions.InvalidURL,
126	requests.exceptions.Timeout,
127	) as exception:
128	msg = "Exception: {}".format(type(exception).__name__)	×
129	msg += "\nException message: {}".format(exception)	×
130	logger.error(msg)	×

EsupPortail / Esup-Pod / 13964928276

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