Merge b83889a20e into 4d05f84325

* no space after @ in decorator

test/test_jsinterp.py

@@ -577,9 +577,11 @@ class TestJSInterpreter(unittest.TestCase):
     def test_unary_operators(self):
         jsi = JSInterpreter('function f(){return 2  -  - - 2;}')
         self.assertEqual(jsi.call_function('f'), 0)
-        # fails
-        # jsi = JSInterpreter('function f(){return 2 + - + - - 2;}')
-        # self.assertEqual(jsi.call_function('f'), 0)
+        jsi = JSInterpreter('function f(){return 2 + - + - - 2;}')
+        self.assertEqual(jsi.call_function('f'), 0)
+        # https://github.com/ytdl-org/youtube-dl/issues/32815
+        jsi = JSInterpreter('function f(){return 0  - 7 * - 6;}')
+        self.assertEqual(jsi.call_function('f'), 42)
 
     """ # fails so far
     def test_packed(self):

test/test_youtube_signature.py

@@ -158,6 +158,10 @@ _NSIG_TESTS = [
         'https://www.youtube.com/s/player/b7910ca8/player_ias.vflset/en_US/base.js',
         '_hXMCwMt9qE310D', 'LoZMgkkofRMCZQ',
     ),
+    (
+        'https://www.youtube.com/s/player/590f65a6/player_ias.vflset/en_US/base.js',
+        '1tm7-g_A9zsI8_Lay_', 'xI4Vem4Put_rOg',
+    ),
 ]
 
 

youtube_dl/extractor/common.py

@@ -3033,7 +3033,6 @@ class InfoExtractor(object):
             transform_source=transform_source, default=None)
 
     def _extract_jwplayer_data(self, webpage, video_id, *args, **kwargs):
-
         # allow passing `transform_source` through to _find_jwplayer_data()
         transform_source = kwargs.pop('transform_source', None)
         kwfind = compat_kwargs({'transform_source': transform_source}) if transform_source else {}
@@ -3324,7 +3323,11 @@ class InfoExtractor(object):
         if (self._downloader.params.get('mark_watched', False)
                 and (self._get_login_info()[0] is not None
                      or self._downloader.params.get('cookiefile') is not None)):
-            self._mark_watched(*args, **kwargs)
+            # extractors apart from YoutubeIE can mark: be more lenient
+            try:
+                self._mark_watched(*args, **kwargs)
+            except NotImplementedError:
+                self.report_warning('Marking as watched is not supported')
 
     def _mark_watched(self, *args, **kwargs):
         raise NotImplementedError('This method must be implemented by subclasses')

youtube_dl/extractor/extractors.py

@@ -917,6 +917,11 @@ from .palcomp3 import (
     PalcoMP3VideoIE,
 )
 from .pandoratv import PandoraTVIE
+from .panopto import (
+    PanoptoIE,
+    PanoptoListIE,
+    PanoptoPlaylistIE,
+ )
 from .parliamentliveuk import ParliamentLiveUKIE
 from .patreon import PatreonIE
 from .pbs import PBSIE

youtube_dl/extractor/generic.py

@@ -132,6 +132,7 @@ from .kinja import KinjaEmbedIE
 from .arcpublishing import ArcPublishingIE
 from .medialaan import MedialaanIE
 from .simplecast import SimplecastIE
+from .panopto import PanoptoIE
 
 
 class GenericIE(InfoExtractor):
@@ -2340,6 +2341,15 @@ class GenericIE(InfoExtractor):
             },
             'expected_warnings': ['uploader id'],
         },
+        {
+            # Panopto embeds
+            'url': 'https://www.monash.edu/learning-teaching/teachhq/learning-technologies/panopto/how-to/insert-a-quiz-into-a-panopto-video',
+            'info_dict': {
+                'title': 'Insert a quiz into a Panopto video',
+                'id': 'insert-a-quiz-into-a-panopto-video'
+            },
+            'playlist_count': 1
+        },
     ]
 
     def report_following_redirect(self, new_url):
@@ -3518,6 +3528,9 @@ class GenericIE(InfoExtractor):
             return self.playlist_from_matches(
                 zype_urls, video_id, video_title, ie=ZypeIE.ie_key())
 
+        panopto_entries = PanoptoIE._extract_from_webpage(url, webpage)
+        if panopto_entries:
+            return self.playlist_result(panopto_entries, video_id, video_title)
         # Look for HTML5 media
         entries = self._parse_html5_media_entries(url, webpage, video_id, m3u8_id='hls')
         if entries:

youtube_dl/extractor/palcomp3.py

@@ -8,7 +8,7 @@ from ..compat import compat_str
 from ..utils import (
     int_or_none,
     str_or_none,
-    try_get,
+    traverse_obj,
 )
 
 
@@ -109,7 +109,7 @@ class PalcoMP3ArtistIE(PalcoMP3BaseIE):
     }
     name'''
 
-    @ classmethod
+    @classmethod
     def suitable(cls, url):
         return False if re.match(PalcoMP3IE._VALID_URL, url) else super(PalcoMP3ArtistIE, cls).suitable(url)
 
@@ -118,7 +118,8 @@ class PalcoMP3ArtistIE(PalcoMP3BaseIE):
         artist = self._call_api(artist_slug, self._ARTIST_FIELDS_TMPL)['artist']
 
         def entries():
-            for music in (try_get(artist, lambda x: x['musics']['nodes'], list) or []):
+            for music in traverse_obj(artist, (
+                    'musics', 'nodes', lambda _, m: m['musicID'])):
                 yield self._parse_music(music)
 
         return self.playlist_result(
@@ -137,7 +138,7 @@ class PalcoMP3VideoIE(PalcoMP3BaseIE):
             'title': 'Maiara e Maraisa - Você Faz Falta Aqui - DVD Ao Vivo Em Campo Grande',
             'description': 'md5:7043342c09a224598e93546e98e49282',
             'upload_date': '20161107',
-            'uploader_id': 'maiaramaraisaoficial',
+            'uploader_id': '@maiaramaraisaoficial',
             'uploader': 'Maiara e Maraisa',
         }
     }]

youtube_dl/extractor/panopto.py

@@ -0,0 +1,663 @@
+# coding: utf-8
+from __future__ import unicode_literals
+
+import calendar
+from datetime import datetime
+import functools
+import json
+import itertools
+from random import random
+import re
+
+from .common import InfoExtractor
+from ..compat import (
+    compat_map as map,
+    compat_parse_qs as parse_qs,
+    compat_str,
+    compat_urllib_parse_urlparse,
+)
+
+from ..utils import (
+    bug_reports_message,
+    ExtractorError,
+    get_first,
+    int_or_none,
+    LazyList,
+    merge_dicts,
+    OnDemandPagedList,
+    orderedSet,
+    srt_subtitles_timecode,
+    traverse_obj,
+    try_get,
+    update_url_query,
+)
+
+import inspect
+if len(try_get(InfoExtractor.report_warning,
+               (lambda x: inspect.getfullargspec(x).FullArgs,
+                lambda x: inspect.getargspec(x).Args, ), list) or []) <= 2:
+
+    BaseInfoExtractor = InfoExtractor
+
+    class InfoExtractor(BaseInfoExtractor):
+
+        def report_warning(self, warning, only_once=True, _memo=set()):
+            from hashlib import md5
+            if only_once:
+                w_hash = md5(warning).hexdigest()
+                if w_hash in _memo:
+                    return
+                _memo.add(w_hash)
+            super(InfoExtractor, self).report_warning(self, warning)
+
+        @classmethod
+        def _match_valid_url(cls, url):
+            return re.match(cls._VALID_URL, url)
+
+        @staticmethod
+        def _merge_subtitle_items(subtitle_list1, subtitle_list2):
+            """ Merge subtitle items for one language. Items with duplicated URLs/data
+            will be dropped. """
+            list1_data = {(item.get('url'), item.get('data')) for item in subtitle_list1}
+            ret = list(subtitle_list1)
+            ret.extend(item for item in subtitle_list2 if (item.get('url'), item.get('data')) not in list1_data)
+            return ret
+
+
+class PanoptoBaseIE(InfoExtractor):
+    BASE_URL_RE = r'(?P<base_url>https?://[\w.-]+\.panopto.(?:com|eu)/Panopto)'
+
+    # see panopto core.js
+    _SUB_LANG_MAPPING = {
+        0: 'en-US',
+        1: 'en-GB',
+        2: 'es-MX',
+        3: 'es-ES',
+        4: 'de-DE',
+        5: 'fr-FR',
+        6: 'nl-NL',
+        7: 'th-TH',
+        8: 'zh-CN',
+        9: 'zh-TW',
+        10: 'ko-KR',
+        11: 'ja-JP',
+        12: 'ru-RU',
+        13: 'pt-PT',
+        14: 'pl-PL',
+        15: 'en-AU',
+        16: 'da-DK',
+        17: 'fi-FI',
+        18: 'hu-HU',
+        19: 'nb-NO',
+        20: 'sv-SE',
+        21: 'it-IT'
+    }
+
+    def _call_api(self, base_url, path, video_id, data=None, fatal=True, **kwargs):
+        response = self._download_json(
+            base_url + path, video_id, data=json.dumps(data).encode('utf8') if data else None,
+            fatal=fatal, headers={'accept': 'application/json', 'content-type': 'application/json'}, **kwargs)
+        if not response:
+            return
+        error_code = traverse_obj(response, 'ErrorCode')
+        if error_code == 2:
+            self.raise_login_required(method='cookies')
+        elif error_code is not None:
+            msg = '%s said: %s' % (self.IE_NAME, response.get('ErrorMessage') or '[no message]')
+            if fatal:
+                raise ExtractorError(msg, video_id=video_id, expected=True)
+            else:
+                self.report_warning(msg, video_id=video_id)
+        return response
+
+    @staticmethod
+    def _parse_fragment(url):
+        return dict((k, json.loads(v[0])) for k, v in parse_qs(compat_urllib_parse_urlparse(url).fragment).items())
+
+
+class PanoptoIE(PanoptoBaseIE):
+    _VALID_URL = PanoptoBaseIE.BASE_URL_RE + r'/Pages/(Viewer|Embed)\.aspx.*(?:\?|&)id=(?P<id>[a-f0-9-]+)'
+    _EMBED_REGEX = [
+        r'''<iframe\b[^>]+\bsrc\s*=\s*(["'])(?P<url>%s/Pages/(?:Viewer|Embed|Sessions/List)\.aspx(?:(?!\1)[\w\W])+)'''
+        % (PanoptoBaseIE.BASE_URL_RE, )]
+    _TESTS = [
+        {
+            'url': 'https://demo.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=26b3ae9e-4a48-4dcc-96ba-0befba08a0fb',
+            'info_dict': {
+                'id': '26b3ae9e-4a48-4dcc-96ba-0befba08a0fb',
+                'title': 'Panopto for Business - Use Cases',
+                'timestamp': 1459184200,
+                'thumbnail': r're:https://demo\.hosted\.panopto\.com/.+',
+                'upload_date': '20160328',
+                'ext': 'mp4',
+                'cast': [],
+                'chapters': [],
+                'duration': 88.17099999999999,
+                'average_rating': int,
+                'uploader_id': '2db6b718-47a0-4b0b-9e17-ab0b00f42b1e',
+                'channel_id': 'e4c6a2fc-1214-4ca0-8fb7-aef2e29ff63a',
+                'channel': 'Showcase Videos'
+            },
+        },
+        {
+            'url': 'https://demo.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=ed01b077-c9e5-4c7b-b8ff-15fa306d7a59',
+            'info_dict': {
+                'id': 'ed01b077-c9e5-4c7b-b8ff-15fa306d7a59',
+                'title': 'Overcoming Top 4 Challenges of Enterprise Video',
+                'uploader': 'Panopto Support',
+                'timestamp': 1449409251,
+                'thumbnail': r're:https://demo\.hosted\.panopto\.com/.+',
+                'upload_date': '20151206',
+                'ext': 'mp4',
+                'chapters': 'count:12',
+                'cast': ['Panopto Support'],
+                'uploader_id': 'a96d1a31-b4de-489b-9eee-b4a5b414372c',
+                'average_rating': int,
+                'description': 'md5:4391837802b3fc856dadf630c4b375d1',
+                'duration': 1088.2659999999998,
+                'channel_id': '9f3c1921-43bb-4bda-8b3a-b8d2f05a8546',
+                'channel': 'Webcasts',
+            },
+        },
+        {
+            # Extra params in URL
+            'url': 'https://howtovideos.hosted.panopto.com/Panopto/Pages/Viewer.aspx?randomparam=thisisnotreal&id=5fa74e93-3d87-4694-b60e-aaa4012214ed&advance=true',
+            'info_dict': {
+                'id': '5fa74e93-3d87-4694-b60e-aaa4012214ed',
+                'ext': 'mp4',
+                'duration': 129.513,
+                'cast': ['Kathryn Kelly'],
+                'uploader_id': '316a0a58-7fa2-4cd9-be1c-64270d284a56',
+                'timestamp': 1569845768,
+                'tags': ['Viewer', 'Enterprise'],
+                'chapters': [],
+                'upload_date': '20190930',
+                'thumbnail': r're:https://howtovideos\.hosted\.panopto\.com/.+',
+                'description': 'md5:2d844aaa1b1a14ad0e2601a0993b431f',
+                'title': 'Getting Started: View a Video',
+                'average_rating': int,
+                'uploader': 'Kathryn Kelly',
+                'channel_id': 'fb93bc3c-6750-4b80-a05b-a921013735d3',
+                'channel': 'Getting Started',
+            }
+        },
+        {
+            # Does not allow normal Viewer.aspx. AUDIO livestream has no url, so should be skipped and only give one stream.
+            'url': 'https://unisa.au.panopto.com/Panopto/Pages/Embed.aspx?id=9d9a0fa3-e99a-4ebd-a281-aac2017f4da4',
+            'info_dict': {
+                'id': '9d9a0fa3-e99a-4ebd-a281-aac2017f4da4',
+                'ext': 'mp4',
+                'cast': ['LTS CLI Script'],
+                'chapters': [],
+                'duration': 2178.45,
+                'description': 'md5:ee5cf653919f55b72bce2dbcf829c9fa',
+                'channel_id': 'b23e673f-c287-4cb1-8344-aae9005a69f8',
+                'average_rating': int,
+                'uploader_id': '38377323-6a23-41e2-9ff6-a8e8004bf6f7',
+                'uploader': 'LTS CLI Script',
+                'timestamp': 1572458134,
+                'title': 'WW2 Vets Interview 3 Ronald Stanley George',
+                'thumbnail': r're:https://unisa\.au\.panopto\.com/.+',
+                'channel': 'World War II Veteran Interviews',
+                'upload_date': '20191030',
+            },
+        },
+        {
+            # Slides/storyboard
+            'url': 'https://demo.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=a7f12f1d-3872-4310-84b0-f8d8ab15326b',
+            'info_dict': {
+                'id': 'a7f12f1d-3872-4310-84b0-f8d8ab15326b',
+                'ext': 'mhtml',
+                'timestamp': 1448798857,
+                'duration': 4712.681,
+                'title': 'Cache Memory - CompSci 15-213, Lecture 12',
+                'channel_id': 'e4c6a2fc-1214-4ca0-8fb7-aef2e29ff63a',
+                'uploader_id': 'a96d1a31-b4de-489b-9eee-b4a5b414372c',
+                'upload_date': '20151129',
+                'average_rating': 0,
+                'uploader': 'Panopto Support',
+                'channel': 'Showcase Videos',
+                'description': 'md5:55e51d54233ddb0e6c2ed388ca73822c',
+                'cast': ['ISR Videographer', 'Panopto Support'],
+                'chapters': 'count:28',
+                'thumbnail': r're:https://demo\.hosted\.panopto\.com/.+',
+            },
+            'params': {'format': 'mhtml', 'skip_download': True},
+            'skip': 'Not yet implemented',
+        },
+        {
+            'url': 'https://na-training-1.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=8285224a-9a2b-4957-84f2-acb0000c4ea9',
+            'info_dict': {
+                'id': '8285224a-9a2b-4957-84f2-acb0000c4ea9',
+                'ext': 'mp4',
+                'chapters': [],
+                'title': 'Company Policy',
+                'average_rating': 0,
+                'timestamp': 1615058901,
+                'channel': 'Human Resources',
+                'tags': ['HumanResources'],
+                'duration': 1604.243,
+                'thumbnail': r're:https://na-training-1\.hosted\.panopto\.com/.+',
+                'uploader_id': '8e8ba0a3-424f-40df-a4f1-ab3a01375103',
+                'uploader': 'Cait M.',
+                'upload_date': '20210306',
+                'cast': ['Cait M.'],
+                # 'subtitles': {'en-US': [{'ext': 'srt', 'data': 'md5:a3f4d25963fdeace838f327097c13265'}],
+                #               'es-ES': [{'ext': 'srt', 'data': 'md5:57e9dad365fd0fbaf0468eac4949f189'}]},
+            },
+            'params': {'writesubtitles': True, 'skip_download': True}
+        }, {
+            # On Panopto there are two subs: "Default" and en-US. en-US is blank and should be skipped.
+            'url': 'https://na-training-1.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=940cbd41-f616-4a45-b13e-aaf1000c915b',
+            'info_dict': {
+                'id': '940cbd41-f616-4a45-b13e-aaf1000c915b',
+                'ext': 'mp4',
+                'subtitles': 'count:1',
+                'title': 'HR Benefits Review Meeting*',
+                'cast': ['Panopto Support'],
+                'chapters': [],
+                'timestamp': 1575024251,
+                'thumbnail': r're:https://na-training-1\.hosted\.panopto\.com/.+',
+                'channel': 'Zoom',
+                'description': 'md5:04f90a9c2c68b7828144abfb170f0106',
+                'uploader': 'Panopto Support',
+                'average_rating': 0,
+                'duration': 409.34499999999997,
+                'uploader_id': 'b6ac04ad-38b8-4724-a004-a851004ea3df',
+                'upload_date': '20191129',
+
+            },
+            'params': {'writesubtitles': True, 'skip_download': True}
+        },
+        {
+            'url': 'https://ucc.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=0e8484a4-4ceb-4d98-a63f-ac0200b455cb',
+            'only_matching': True
+        },
+        {
+            'url': 'https://brown.hosted.panopto.com/Panopto/Pages/Embed.aspx?id=0b3ff73b-36a0-46c5-8455-aadf010a3638',
+            'only_matching': True
+        },
+    ]
+
+    @classmethod
+    def suitable(cls, url):
+        return False if PanoptoPlaylistIE.suitable(url) else super(PanoptoIE, cls).suitable(url)
+
+    @classmethod
+    def _extract_from_webpage(cls, url, webpage):
+        return LazyList(map(
+            lambda u: cls.url_result(u, cls.ie_key()),
+            orderedSet(m.group('url') for m in itertools.chain(
+                *(re.finditer(embed_re, webpage) for embed_re in cls._EMBED_REGEX)))))
+
+    def _mark_watched(self, base_url, video_id, delivery_info):
+        duration = traverse_obj(delivery_info, ('Delivery', 'Duration'), expected_type=float)
+        invocation_id = delivery_info.get('InvocationId')
+        stream_id = traverse_obj(delivery_info, ('Delivery', 'Streams', Ellipsis, 'PublicID'), get_all=False, expected_type=compat_str)
+        if invocation_id and stream_id and duration:
+            timestamp_str = '/Date(%s000)/' % (calendar.timegm(datetime.utcnow().timetuple()), )
+            data = {
+                'streamRequests': [
+                    {
+                        'ClientTimeStamp': timestamp_str,
+                        'ID': 0,
+                        'InvocationID': invocation_id,
+                        'PlaybackSpeed': 1,
+                        'SecondsListened': duration - 1,
+                        'SecondsRejected': 0,
+                        'StartPosition': 0,
+                        'StartReason': 2,
+                        'StopReason': None,
+                        'StreamID': stream_id,
+                        'TimeStamp': timestamp_str,
+                        'UpdatesRejected': 0
+                    },
+                ]}
+
+            self._download_webpage(
+                base_url + '/Services/Analytics.svc/AddStreamRequests', video_id,
+                fatal=False, data=json.dumps(data).encode('utf8'), headers={'content-type': 'application/json'},
+                note='Marking watched', errnote='Unable to mark watched')
+
+    @staticmethod
+    def _extract_chapters(timestamps):
+        chapters = []
+        for timestamp in timestamps or []:
+            caption = timestamp.get('Caption')
+            start, duration = int_or_none(timestamp.get('Time')), int_or_none(timestamp.get('Duration'))
+            if not caption or start is None or duration is None:
+                continue
+            chapters.append({
+                'start_time': start,
+                'end_time': start + duration,
+                'title': caption
+            })
+        return chapters
+
+    @staticmethod
+    def _extract_mhtml_formats(base_url, timestamps):
+        image_frags = {}
+        for timestamp in timestamps or []:
+            duration = timestamp.get('Duration')
+            obj_id, obj_sn = timestamp.get('ObjectIdentifier'), timestamp.get('ObjectSequenceNumber'),
+            if timestamp.get('EventTargetType') == 'PowerPoint' and obj_id is not None and obj_sn is not None:
+                image_frags.setdefault('slides', []).append({
+                    'url': update_url_query(
+                        base_url + '/Pages/Viewer/Image.aspx', {
+                            'id': obj_id,
+                            'number': obj_sn,
+                        }),
+                    'duration': duration
+                })
+
+            obj_pid, session_id, abs_time = timestamp.get('ObjectPublicIdentifier'), timestamp.get('SessionID'), timestamp.get('AbsoluteTime')
+            if None not in (obj_pid, session_id, abs_time):
+                image_frags.setdefault('chapter', []).append({
+                    'url': update_url_query(
+                        base_url + '/Pages/Viewer/Thumb.aspx?isPrimary=false', {
+                            'eventTargetPID': obj_pid,
+                            'sessionPID': session_id,
+                            'number': obj_sn,
+                            'absoluteTime': abs_time,
+                        }),
+                    'duration': duration,
+                })
+        for name, fragments in image_frags.items():
+            yield {
+                'format_id': name,
+                'ext': 'mhtml',
+                'protocol': 'mhtml',
+                'acodec': 'none',
+                'vcodec': 'none',
+                'url': 'about:invalid',
+                'fragments': fragments
+            }
+
+    @staticmethod
+    def _json2srt(data, delivery):
+        SRT_CAPTION_FMT = '{0}\n{1} --> {2}\n{3}'
+
+        def gen_lines(dat, deliv):
+            for i, line in enumerate(dat):
+                start_time = line['Time']
+                duration = line.get('Duration')
+                if duration:
+                    end_time = start_time + duration
+                else:
+                    end_time = traverse_obj(dat, (i + 1, 'Time')) or deliv['Duration']
+                yield SRT_CAPTION_FMT.format(
+                    i + 1, srt_subtitles_timecode(start_time), srt_subtitles_timecode(end_time), line['Caption'])
+        return '\n\n'.join(gen_lines(data, delivery))
+
+    def _get_subtitles(self, base_url, video_id, delivery):
+        subtitles = {}
+        for lang in delivery.get('AvailableLanguages') or []:
+            response = self._call_api(
+                base_url, '/Pages/Viewer/DeliveryInfo.aspx', video_id, fatal=False,
+                note='Downloading captions JSON metadata', query={
+                    'deliveryId': video_id,
+                    'getCaptions': True,
+                    'language': compat_str(lang),
+                    'responseType': 'json'
+                }
+            )
+            if not isinstance(response, list):
+                continue
+            subtitles.setdefault(self._SUB_LANG_MAPPING.get(lang) or 'default', []).append({
+                'ext': 'srt',
+                'data': self._json2srt(response, delivery),
+            })
+        return subtitles
+
+    def _extract_streams_formats_and_subtitles(self, video_id, streams, **fmt_kwargs):
+        formats = []
+        subtitles = {}
+        for stream in streams or []:
+            stream_formats = []
+            http_stream_url = stream.get('StreamHttpUrl')
+            stream_url = stream.get('StreamUrl')
+
+            if http_stream_url:
+                stream_formats.append({'url': http_stream_url})
+
+            if stream_url:
+                media_type = stream.get('ViewerMediaFileTypeName')
+                if media_type in ('hls', ):
+                    # m3u8_formats, stream_subtitles = self._extract_m3u8_formats_and_subtitles(stream_url, video_id)
+                    m3u8_formats = self._extract_m3u8_formats(stream_url, video_id)
+                    stream_formats.extend(m3u8_formats)
+                    # subtitles = self._merge_subtitles(subtitles, stream_subtitles)
+                else:
+                    stream_formats.append({
+                        'url': stream_url
+                    })
+            for fmt in stream_formats:
+                fmt.update({'format_note': stream.get('Tag'), })
+                fmt.update(fmt_kwargs)
+            formats.extend(stream_formats)
+
+        return formats, subtitles
+
+    def _real_extract(self, url):
+        base_url, video_id = self._match_valid_url(url).group('base_url', 'id')
+        delivery_info = self._call_api(
+            base_url, '/Pages/Viewer/DeliveryInfo.aspx', video_id,
+            query={
+                'deliveryId': video_id,
+                'invocationId': '',
+                'isLiveNotes': 'false',
+                'refreshAuthCookie': 'true',
+                'isActiveBroadcast': 'false',
+                'isEditing': 'false',
+                'isKollectiveAgentInstalled': 'false',
+                'isEmbed': 'false',
+                'responseType': 'json',
+            }
+        )
+
+        delivery = delivery_info['Delivery']
+        session_start_time = int_or_none(delivery.get('SessionStartTime'))
+        timestamps = delivery.get('Timestamps')
+
+        # Podcast stream is usually the combined streams. We will prefer that by default.
+        podcast_formats, podcast_subtitles = self._extract_streams_formats_and_subtitles(
+            video_id, delivery.get('PodcastStreams'), format_note='PODCAST')
+
+        streams_formats, streams_subtitles = self._extract_streams_formats_and_subtitles(
+            video_id, delivery.get('Streams'), preference=-10)
+
+        formats = podcast_formats + streams_formats
+        formats.extend(self._extract_mhtml_formats(base_url, timestamps))
+        subtitles = self._merge_subtitles(podcast_subtitles, streams_subtitles)
+        subtitles = self._merge_subtitles(subtitles, self.extract_subtitles(base_url, video_id, delivery))
+
+        self._sort_formats(formats)
+        self.mark_watched(base_url, video_id, delivery_info)
+
+        return {
+            'id': video_id,
+            'title': delivery.get('SessionName'),
+            'cast': traverse_obj(delivery, ('Contributors', Ellipsis, 'DisplayName'), default=[], expected_type=lambda x: x or None),
+            'timestamp': session_start_time - 11640000000 if session_start_time else None,
+            'duration': delivery.get('Duration'),
+            'thumbnail': update_url_query(
+                base_url + '/Services/FrameGrabber.svc/FrameRedirect?mode=Delivery', {
+                    'objectId': video_id,
+                    'random': random(),
+                }),
+            'average_rating': delivery.get('AverageRating'),
+            'chapters': self._extract_chapters(timestamps),
+            'uploader': delivery.get('OwnerDisplayName') or None,
+            'uploader_id': delivery.get('OwnerId'),
+            'description': delivery.get('SessionAbstract'),
+            'tags': traverse_obj(delivery, ('Tags', Ellipsis, 'Content')),
+            'channel_id': delivery.get('SessionGroupPublicID'),
+            'channel': traverse_obj(delivery, 'SessionGroupLongName', 'SessionGroupShortName', get_all=False),
+            'formats': formats,
+            'subtitles': subtitles
+        }
+
+
+class PanoptoPlaylistIE(PanoptoBaseIE):
+    _VALID_URL = PanoptoBaseIE.BASE_URL_RE + r'/Pages/(Viewer|Embed)\.aspx.*(?:\?|&)pid=(?P<id>[a-f0-9-]+)'
+    _TESTS = [
+        {
+            'url': 'https://howtovideos.hosted.panopto.com/Panopto/Pages/Viewer.aspx?pid=f3b39fcf-882f-4849-93d6-a9f401236d36&id=5fa74e93-3d87-4694-b60e-aaa4012214ed&advance=true',
+            'info_dict': {
+                'title': 'Featured Video Tutorials',
+                'id': 'f3b39fcf-882f-4849-93d6-a9f401236d36',
+            },
+            'playlist_mincount': 34,  # was 36
+        },
+        {
+            'url': 'https://utsa.hosted.panopto.com/Panopto/Pages/Viewer.aspx?pid=e2900555-3ad4-4bdb-854d-ad2401686190',
+            'info_dict': {
+                'title': 'Library Website Introduction Playlist',
+                'id': 'e2900555-3ad4-4bdb-854d-ad2401686190',
+                'description': 'md5:f958bca50a1cbda15fdc1e20d32b3ecb',
+            },
+            'playlist_mincount': 4
+        },
+    ]
+
+    def _entries(self, base_url, playlist_id, session_list_id):
+        session_list_info = self._call_api(
+            base_url,
+            '/Api/SessionLists/%s?collections[0].maxCount=500&collections[0].name=items' % (session_list_id, ),
+            playlist_id)
+
+        items = session_list_info['Items']
+        for item in items:
+            if item.get('TypeName') != 'Session':
+                self.report_warning('Got an item in the playlist that is not a Session' + bug_reports_message(), only_once=True)
+                continue
+            yield merge_dicts(
+                self.url_result(item.get('ViewerUri'), item.get('Id'), item.get('Name')), {
+                    'description': item.get('Description'),
+                    'duration': item.get('Duration'),
+                    'channel': traverse_obj(item, ('Parent', 'Name')),
+                    'channel_id': traverse_obj(item, ('Parent', 'Id'))
+                })
+
+    def _real_extract(self, url):
+        base_url, playlist_id = self._match_valid_url(url).group('base_url', 'id')
+
+        video_id = get_first(parse_qs(url), 'id')
+        if video_id:
+            if self.get_param('noplaylist'):
+                self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
+                return self.url_result(update_url_query(base_url + '/Pages/Viewer.aspx', {'id': video_id}), ie_key=PanoptoIE.ie_key(), video_id=video_id)
+            else:
+                self.to_screen('Downloading playlist {playlist_id}; add --no-playlist to just download video {video_id}'.format(**locals()))
+
+        playlist_info = self._call_api(base_url, '/Api/Playlists/' + playlist_id, playlist_id)
+        return self.playlist_result(
+            self._entries(base_url, playlist_id, playlist_info['SessionListId']),
+            playlist_id=playlist_id, playlist_title=playlist_info.get('Name'),
+            playlist_description=playlist_info.get('Description'))
+
+
+class PanoptoListIE(PanoptoBaseIE):
+    _VALID_URL = PanoptoBaseIE.BASE_URL_RE + r'/Pages/Sessions/List\.aspx'
+    _PAGE_SIZE = 250
+    _TESTS = [
+        {
+            'url': 'https://demo.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#folderID=%22e4c6a2fc-1214-4ca0-8fb7-aef2e29ff63a%22',
+            'info_dict': {
+                'id': 'e4c6a2fc-1214-4ca0-8fb7-aef2e29ff63a',
+                'title': 'Showcase Videos'
+            },
+            'playlist_mincount': 140
+
+        },
+        {
+            'url': 'https://demo.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#view=2&maxResults=250',
+            'info_dict': {
+                'id': 'panopto_list',
+                'title': 'panopto_list'
+            },
+            'playlist_mincount': 300
+        },
+        {
+            # Folder that contains 8 folders and a playlist
+            'url': 'https://howtovideos.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx?noredirect=true#folderID=%224b9de7ae-0080-4158-8496-a9ba01692c2e%22',
+            'info_dict': {
+                'id': '4b9de7ae-0080-4158-8496-a9ba01692c2e',
+                'title': 'Video Tutorials'
+            },
+            'playlist_mincount': 9
+        }
+
+    ]
+
+    def _fetch_page(self, base_url, query_params, display_id, page):
+        params = merge_dicts({
+            'page': page,
+            'maxResults': self._PAGE_SIZE,
+        }, query_params, {
+            'sortColumn': 1,
+            'getFolderData': True,
+            'includePlaylists': True,
+        })
+
+        response = self._call_api(
+            base_url, '/Services/Data.svc/GetSessions', '%s page %d' % (display_id, page + 1),
+            data={'queryParameters': params}, fatal=False)
+
+        for result in get_first(response, 'Results', default=[]):
+            # This could be a video, playlist (or maybe something else)
+            item_id = result.get('DeliveryID')
+            yield merge_dicts(
+                self.url_result(
+                    traverse_obj(result, 'ViewerUrl', 'EmbedUrl', get_all=False)
+                    or update_url_query(base_url + '/Pages/Viewer.aspx', {'id': item_id}),
+                    item_id, result.get('SessionName')), {
+                    'duration': result.get('Duration'),
+                    'channel': result.get('FolderName'),
+                    'channel_id': result.get('FolderID'),
+                })
+
+        for folder in get_first(response, 'Subfolders', default=[]):
+            folder_id = folder.get('ID')
+            yield self.url_result(
+                '%s/Pages/Sessions/List.aspx#folderID=%s' % (base_url, folder_id),
+                ie_key=PanoptoListIE.ie_key(), video_id=folder_id, title=folder.get('Name'))
+
+    def _extract_folder_metadata(self, base_url, folder_id):
+        response = self._call_api(
+            base_url, '/Services/Data.svc/GetFolderInfo', folder_id,
+            data={'folderID': folder_id}, fatal=False)
+        return {
+            'title': get_first(response, 'Name', default=[])
+        }
+
+    def _real_extract(self, url):
+        mobj = self._match_valid_url(url)
+        base_url = mobj.group('base_url')
+
+        query_params = self._parse_fragment(url)
+        folder_id, display_id = query_params.get('folderID'), 'panopto_list'
+
+        if query_params.get('isSubscriptionsPage'):
+            display_id = 'subscriptions'
+            if not query_params.get('subscribableTypes'):
+                query_params['subscribableTypes'] = [0, 1, 2]
+        elif query_params.get('isSharedWithMe'):
+            display_id = 'sharedwithme'
+        elif folder_id:
+            display_id = folder_id
+
+        query = query_params.get('query')
+        if query:
+            display_id += ': query "%s"' % (query, )
+
+        info = self.playlist_result(
+            OnDemandPagedList(
+                functools.partial(self._fetch_page, base_url, query_params, display_id), self._PAGE_SIZE),
+            playlist_id=display_id,
+            playlist_title=display_id)
+
+        if folder_id:
+            info.update(self._extract_folder_metadata(base_url, folder_id))
+
+        return info

youtube_dl/jsinterp.py

@@ -14,6 +14,7 @@ from .utils import (
     remove_quotes,
     unified_timestamp,
     variadic,
+    write_string,
 )
 from .compat import (
     compat_basestring,
@@ -53,15 +54,16 @@ def wraps_op(op):
 
 # NB In principle NaN cannot be checked by membership.
 # Here all NaN values are actually this one, so _NaN is _NaN,
-# although _NaN != _NaN.
+# although _NaN != _NaN. Ditto Infinity.
 
 _NaN = float('nan')
+_Infinity = float('inf')
 
 
 def _js_bit_op(op):
 
     def zeroise(x):
-        return 0 if x in (None, JS_Undefined, _NaN) else x
+        return 0 if x in (None, JS_Undefined, _NaN, _Infinity) else x
 
     @wraps_op(op)
     def wrapped(a, b):
@@ -84,7 +86,7 @@ def _js_arith_op(op):
 def _js_div(a, b):
     if JS_Undefined in (a, b) or not (a or b):
         return _NaN
-    return operator.truediv(a or 0, b) if b else float('inf')
+    return operator.truediv(a or 0, b) if b else _Infinity
 
 
 def _js_mod(a, b):
@@ -220,6 +222,42 @@ class LocalNameSpace(ChainMap):
         return 'LocalNameSpace%s' % (self.maps, )
 
 
+class Debugger(object):
+    ENABLED = False
+
+    @staticmethod
+    def write(*args, **kwargs):
+        level = kwargs.get('level', 100)
+
+        def truncate_string(s, left, right=0):
+            if s is None or len(s) <= left + right:
+                return s
+            return '...'.join((s[:left - 3], s[-right:] if right else ''))
+
+        write_string('[debug] JS: {0}{1}\n'.format(
+            '  ' * (100 - level),
+            ' '.join(truncate_string(compat_str(x), 50, 50) for x in args)))
+
+    @classmethod
+    def wrap_interpreter(cls, f):
+        def interpret_statement(self, stmt, local_vars, allow_recursion, *args, **kwargs):
+            if cls.ENABLED and stmt.strip():
+                cls.write(stmt, level=allow_recursion)
+            try:
+                ret, should_ret = f(self, stmt, local_vars, allow_recursion, *args, **kwargs)
+            except Exception as e:
+                if cls.ENABLED:
+                    if isinstance(e, ExtractorError):
+                        e = e.orig_msg
+                    cls.write('=> Raises:', e, '<-|', stmt, level=allow_recursion)
+                raise
+            if cls.ENABLED and stmt.strip():
+                if should_ret or not repr(ret) == stmt:
+                    cls.write(['->', '=>'][should_ret], repr(ret), '<-|', stmt, level=allow_recursion)
+            return ret, should_ret
+        return interpret_statement
+
+
 class JSInterpreter(object):
     __named_object_counter = 0
 
@@ -307,8 +345,7 @@ class JSInterpreter(object):
     def __op_chars(cls):
         op_chars = set(';,[')
         for op in cls._all_operators():
-            for c in op[0]:
-                op_chars.add(c)
+            op_chars.update(op[0])
         return op_chars
 
     def _named_object(self, namespace, obj):
@@ -326,9 +363,8 @@ class JSInterpreter(object):
         # collections.Counter() is ~10% slower in both 2.7 and 3.9
         counters = dict((k, 0) for k in _MATCHING_PARENS.values())
         start, splits, pos, delim_len = 0, 0, 0, len(delim) - 1
-        in_quote, escaping, skipping = None, False, 0
-        after_op, in_regex_char_group = True, False
-
+        in_quote, escaping, after_op, in_regex_char_group = None, False, True, False
+        skipping = 0
         for idx, char in enumerate(expr):
             paren_delta = 0
             if not in_quote:
@@ -382,10 +418,12 @@ class JSInterpreter(object):
         return separated[0][1:].strip(), separated[1].strip()
 
     @staticmethod
-    def _all_operators():
-        return itertools.chain(
-            # Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
-            _SC_OPERATORS, _LOG_OPERATORS, _COMP_OPERATORS, _OPERATORS)
+    def _all_operators(_cached=[]):
+        if not _cached:
+            _cached.extend(itertools.chain(
+                # Ref: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence
+                _SC_OPERATORS, _LOG_OPERATORS, _COMP_OPERATORS, _OPERATORS))
+        return _cached
 
     def _operator(self, op, left_val, right_expr, expr, local_vars, allow_recursion):
         if op in ('||', '&&'):
@@ -416,7 +454,7 @@ class JSInterpreter(object):
         except Exception as e:
             if allow_undefined:
                 return JS_Undefined
-            raise self.Exception('Cannot get index {idx:.100}'.format(**locals()), expr=repr(obj), cause=e)
+            raise self.Exception('Cannot get index {idx!r:.100}'.format(**locals()), expr=repr(obj), cause=e)
 
     def _dump(self, obj, namespace):
         try:
@@ -438,6 +476,7 @@ class JSInterpreter(object):
     _FINALLY_RE = re.compile(r'finally\s*\{')
     _SWITCH_RE = re.compile(r'switch\s*\(')
 
+    @Debugger.wrap_interpreter
     def interpret_statement(self, stmt, local_vars, allow_recursion=100):
         if allow_recursion < 0:
             raise self.Exception('Recursion limit reached')
@@ -511,7 +550,6 @@ class JSInterpreter(object):
                 expr = self._dump(inner, local_vars) + outer
 
         if expr.startswith('('):
-
             m = re.match(r'\((?P<d>[a-z])%(?P<e>[a-z])\.length\+(?P=e)\.length\)%(?P=e)\.length', expr)
             if m:
                 # short-cut eval of frequently used `(d%e.length+e.length)%e.length`, worth ~6% on `pytest -k test_nsig`
@@ -693,7 +731,7 @@ class JSInterpreter(object):
                 (?P<op>{_OPERATOR_RE})?
                 =(?!=)(?P<expr>.*)$
             )|(?P<return>
-                (?!if|return|true|false|null|undefined)(?P<name>{_NAME_RE})$
+                (?!if|return|true|false|null|undefined|NaN|Infinity)(?P<name>{_NAME_RE})$
             )|(?P<indexing>
                 (?P<in>{_NAME_RE})\[(?P<idx>.+)\]$
             )|(?P<attribute>
@@ -727,11 +765,12 @@ class JSInterpreter(object):
             raise JS_Break()
         elif expr == 'continue':
             raise JS_Continue()
-
         elif expr == 'undefined':
             return JS_Undefined, should_return
         elif expr == 'NaN':
             return _NaN, should_return
+        elif expr == 'Infinity':
+            return _Infinity, should_return
 
         elif md.get('return'):
             return local_vars[m.group('name')], should_return
@@ -760,18 +799,28 @@ class JSInterpreter(object):
             right_expr = separated.pop()
             # handle operators that are both unary and binary, minimal BODMAS
             if op in ('+', '-'):
+                # simplify/adjust consecutive instances of these operators
                 undone = 0
                 while len(separated) > 1 and not separated[-1].strip():
                     undone += 1
                     separated.pop()
                 if op == '-' and undone % 2 != 0:
                     right_expr = op + right_expr
+                elif op == '+':
+                    while len(separated) > 1 and separated[-1].strip() in self.OP_CHARS:
+                        right_expr = separated.pop() + right_expr
+                # hanging op at end of left => unary + (strip) or - (push right)
                 left_val = separated[-1]
                 for dm_op in ('*', '%', '/', '**'):
                     bodmas = tuple(self._separate(left_val, dm_op, skip_delims=skip_delim))
                     if len(bodmas) > 1 and not bodmas[-1].strip():
                         expr = op.join(separated) + op + right_expr
-                        right_expr = None
+                        if len(separated) > 1:
+                            separated.pop()
+                            right_expr = op.join((left_val, right_expr))
+                        else:
+                            separated = [op.join((left_val, right_expr))]
+                            right_expr = None
                         break
                 if right_expr is None:
                     continue
@@ -797,6 +846,8 @@ class JSInterpreter(object):
 
             def eval_method():
                 if (variable, member) == ('console', 'debug'):
+                    if Debugger.ENABLED:
+                        Debugger.write(self.interpret_expression('[{}]'.format(arg_str), local_vars, allow_recursion))
                     return
                 types = {
                     'String': compat_str,

youtube_dl/options.py

@@ -186,11 +186,11 @@ def parseOpts(overrideArguments=None):
     general.add_option(
         '--mark-watched',
         action='store_true', dest='mark_watched', default=False,
-        help='Mark videos watched (YouTube only)')
+        help='Mark videos watched (if supported for site)')
     general.add_option(
         '--no-mark-watched',
         action='store_false', dest='mark_watched', default=False,
-        help='Do not mark videos watched (YouTube only)')
+        help='Do not mark videos watched')
     general.add_option(
         '--no-color', '--no-colors',
         action='store_true', dest='no_color',

youtube_dl/utils.py

@@ -2406,7 +2406,7 @@ class ExtractorError(YoutubeDLError):
         """ tb, if given, is the original traceback (so that it can be printed out).
         If expected is set, this is a normal error message and most likely not a bug in youtube-dl.
         """
-
+        self.orig_msg = msg
         if sys.exc_info()[0] in (compat_urllib_error.URLError, socket.timeout, UnavailableVideoError):
             expected = True
         if video_id is not None: